ree 1.0.0

data/lib/ree/core/package_schema_loader.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal  = true
+
+require 'json'
+require 'pathname'
+
+class Ree::PackageSchemaLoader
+  # Sample Package.schema.json
+  # {
+  #   "schema_type": "package",
+  #   "ree_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.exists?(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
+
+    ree_version = json_schema.fetch(Schema::REE_VERSION)
+    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_ree_version(ree_version)
+        .set_entry_rpath(entry_rpath)
+        .set_schema_rpath(schema_rpath)
+    else
+      Ree::Package.new(
+        ree_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]
+
+      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.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/core/packages_detector.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal  = true
+
+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]}]]
+  def call(dir, gem_name = nil)
+    if !Dir.exists?(dir)
+      raise Ree::Error.new("dir does not exist: #{dir}", :invalid_dir)
+    end
+
+    files = File.join(dir, "**/", Ree::PACKAGE_SCHEMA_FILE)
+    names = {}
+
+    Dir[files].map do |file|
+      package_schema_path = Pathname
+        .new(file)
+        .relative_path_from(Pathname.new(dir))
+        .to_s
+
+      name = package_schema_path.split('/')[-2]
+      entry_path = Ree::PathHelper.package_entry_path(package_schema_path)
+
+      if !File.exists?(File.join(dir, entry_path))
+        Ree.logger.error("Entry file does not exist for '#{name}' package: #{entry_path}")
+      end
+
+      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
+
+      names[name] = entry_path
+
+      {
+        name: name.to_sym,
+        entry_path: entry_path,
+        package_schema_path: package_schema_path,
+        gem_name: gem_name
+      }
+    end
+  end
+end

data/lib/ree/core/packages_schema.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal  = true
+
+module Ree::PackagesSchema
+  SCHEMA_TYPE = 'schema_type'
+  REE_VERSION = 'ree_version'
+  PACKAGES = 'packages'
+  GEM_PACKAGES = 'gem_packages'
+  
+  module Packages
+    NAME = 'name'
+    SCHEMA = 'schema'
+    GEM = 'gem'
+  end
+
+  module GemPackages
+    NAME = 'name'
+    SCHEMA = 'schema'
+  end
+end

data/lib/ree/core/packages_schema_builder.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal  = true
+
+require 'pathname'
+require 'json'
+
+class Ree::PackagesSchemaBuilder
+  Schema = Ree::PackagesSchema
+
+  def initialize
+    @packages_detector = Ree::PackagesDetector.new
+  end
+
+  # @dir [String] - path to root project dir
+  def call
+    packages = @packages_detector.call(Ree.root_dir)
+    gem_packages = []
+
+    Ree.gems.each do |gem|
+      gem_packages += @packages_detector.call(gem.dir, gem.name)
+    end
+
+    result = {
+      Schema::REE_VERSION => Ree::VERSION,
+      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::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),
+        }
+      },
+    }
+
+    json = JSON.pretty_generate(result)
+
+    File.write(
+      File.join(Ree.root_dir, Ree::PACKAGES_SCHEMA_FILE),
+      json,
+      mode: 'w'
+    )
+    
+    result
+  end
+end

data/lib/ree/core/packages_schema_loader.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal  = true
+
+require 'json'
+
+class Ree::PackagesSchemaLoader
+  # Sample Packages.schema.json
+  # {
+  #   "schema_type": "packages",
+  #   "ree_version": "1.2.3",
+  #   "packages": [
+  #     {
+  #       "name": "accounts",
+  #       "schema": "bc/accounts/Package.schema.json"
+  #     },
+  #     {
+  #       "name": "tests",
+  #       "schema": "bc/tests/Package.schema.json"
+  #     }
+  #   ]
+  # }
+  
+  Schema = Ree::PackagesSchema
+  
+  # @param [String] path Absolute path to Packages.schema.json file
+  # @param Nilor[Ree::PackagesStore] packages_store Existing packages store
+  # @return [Ree::PackagesStore]
+  def call(abs_schema_path, packages_store = nil, gem_name = nil)
+    if !File.exists?(abs_schema_path)
+      raise Ree::Error.new("File not found: #{abs_schema_path}", :invalid_packages_schema)
+    end
+
+    schema = begin
+      JSON.load_file(abs_schema_path)
+    rescue
+      raise Ree::Error.new("Invalid content: #{abs_schema_path}", :invalid_packages_schema)
+    end
+
+    schema_type = schema.fetch(Schema::SCHEMA_TYPE)
+    
+    if schema_type != Schema::PACKAGES
+      raise Ree::Error.new("Invalid schema type: #{abs_schema_path}", :invalid_packages_schema)
+    end
+
+    ree_version = schema.fetch(Schema::REE_VERSION)
+    data = schema.fetch(Schema::PACKAGES)
+    packages_store ||= Ree::PackagesStore.new(ree_version)
+    names = {}
+
+    data.each do |item|
+      name = item[Schema::Packages::NAME].to_s
+      schema_rpath = item[Schema::Packages::SCHEMA].to_s
+      list = [name, schema]
+
+      if list.reject(&:empty?).size != list.size
+        raise Ree::Error.new("invalid package data for: #{item.inspect}", :invalid_packages_schema)
+      end
+
+      if names.has_key?(name)
+        raise Ree::Error.new("duplicate package name for '#{item[:name]}'", :invalid_packages_schema)
+      end
+
+      names[name] = true
+
+      package = Ree::Package.new(
+        ree_version,
+        name.to_sym,
+        Ree::PathHelper.package_entry_path(schema_rpath),
+        schema_rpath,
+        gem_name
+      )
+
+      existing = packages_store.get(package.name)
+
+      if existing && existing.gem_name != package.gem_name
+        if existing.gem_name.nil?
+          raise Ree::Error.new("Unable to add package `#{existing.name}` from `#{package.gem_name}` gem. Project has same package definition.", :duplicate_package)
+        else
+          raise Ree::Error.new("Unable to add package `#{existing.name}` from `#{package.gem_name}` gem. Package was already added from `#{existing.gem_name}` gem.", :duplicate_package)
+        end
+      end
+      
+      packages_store.add_package(
+        Ree::Package.new(
+          ree_version,
+          name.to_sym,
+          Ree::PathHelper.package_entry_path(schema_rpath),
+          schema_rpath,
+          gem_name
+        )
+      )
+    end
+
+    packages_store
+  end
+end

data/lib/ree/core/packages_schema_locator.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal  = true
+
+class Ree::PackagesSchemaLocator
+  def call(path)
+    find_source_path_in_hierarchy(path)
+  end
+
+  private
+
+  def find_source_path_in_hierarchy(some_path)
+    some_path = File.expand_path(some_path)
+
+    raise Ree::Error.new("#{Ree::PACKAGES_SCHEMA_FILE} not found", :packages_json_not_found) if some_path == '/'
+
+    return potential_file(some_path) if present?(some_path)
+    
+    find_source_path_in_hierarchy(File.dirname(some_path))
+  end
+
+  def present?(some_path)
+    File.exist?(potential_file(some_path))
+  end
+
+  def potential_file(some_path)
+    File.join(some_path, Ree::PACKAGES_SCHEMA_FILE)
+  end
+end

data/lib/ree/core/packages_store.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal  = true
+
+class Ree::PackagesStore
+  attr_reader :ree_version
+  
+  def initialize(ree_version = Ree::VERSION)
+    @ree_version = ree_version
+    @store = {}
+  end
+
+  def set_ree_version(val)
+    @ree_version = val; self
+  end
+
+  def packages
+    @store.values
+  end
+
+  # @param [Symbol] name
+  # @return [Ree::Package]
+  def get(name)
+    @store[name]
+  end
+
+  # @param [Ree::Package] package
+  def add_package(package)
+    existing = get(package.name)
+    return existing if existing
+    
+    @store[package.name] = package
+  end
+end

data/lib/ree/core/path_helper.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal  = true
+
+require 'pathname'
+
+class Ree::PathHelper
+  SCHEMAS_FOLDER = 'schemas'
+
+  class << self
+    def abs_package_object_schemas_path(package)
+      root_dir = project_root_dir(package)
+      File.join(root_dir, SCHEMAS_FOLDER)
+    end
+
+    # @param [Ree::Object] object
+    # @return [String] Absolute object file path
+    def abs_object_path(object)
+      package = Ree.container.packages_facade.get_package(object.package_name)
+      File.join(project_root_dir(package), object.rpath)
+    end
+
+    # @param [Ree::Object] object
+    # @return [String] Absolute object schema path
+    def abs_object_schema_path(object)
+      package = Ree.container.packages_facade.get_package(object.package_name)
+      File.join(project_root_dir(package), object.schema_rpath)
+    end
+
+    # @param [String] schema_path Relative path of an object schema (ex. bc/accounts/schemas/accounts/object.schema.json)
+    # @return [String] Relative path to a object source file (ex. bc/accounts/object.rb)
+    def object_rpath(schema_rpath)
+      nodes = schema_rpath.split('/')
+      index = nodes.index(SCHEMAS_FOLDER)
+      nodes[index] = Ree::PACKAGE
+      object_name = nodes[-1].split('.').first
+      filename = "#{object_name}.rb"
+      nodes[-1] = filename
+      nodes.join('/')
+    end
+
+    # @param [String] object_rpath Relative path of an object (bc/accounts/package/accounts/object.rb)
+    # @return [String] Relative path of a object schema (ex. bc/accounts/schemas/accounts/object.schema.json)
+    def object_schema_rpath(object_rpath)
+      nodes = object_rpath.split('/')
+      index = nodes.index(Ree::PACKAGE)
+      nodes[index] = Ree::SCHEMAS
+      filename = File.basename(nodes[-1], '.*')
+      schema_name = "#{filename}.#{Ree::SCHEMA}.json"
+      nodes[-1] = schema_name
+      nodes.join('/')
+    end
+
+    # @param [String] schema_path Absolute or relative path of a package schema (bc/accounts/package/accounts/Package.json)
+    # @return [String] Absolute or relative path of a package entry file (ex. bc/accounts/schemas/accounts.rb)
+    def package_entry_path(schema_path)
+      dir = Pathname.new(schema_path).dirname.to_s
+      name = dir.split('/').last
+      File.join(dir, "#{Ree::PACKAGE}/#{name}.rb")
+    end
+
+    # @param [Ree::Package] package Package schema
+    # @return [String] Absolute package entry path (ex. /data/project/bc/accounts/package/accounts.rb)
+    def abs_package_entry_path(package)
+      File.join(project_root_dir(package), package.entry_rpath)
+    end
+
+    # @param [Ree::Package] package Package schema
+    # @return [String] Absolute package folder path (ex. /data/project/bc/accounts/package/accounts)
+    def abs_package_module_dir(package)
+      File.join(
+        project_root_dir(package), package.dir, Ree::PACKAGE, package.name.to_s
+      )
+    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)
+      File.join(project_root_dir(package), package.dir)
+    end
+
+    # @param [Ree::Package] package Package schema
+    # @param [String] absolute file path
+    # @return [String] File path relative to package (ex. accounts/entities/user.rb)
+    def package_relative_path(package, path)
+      Pathname
+        .new(path)
+        .relative_path_from(File.join(Ree.root_dir, package.dir, Ree::PACKAGE))
+        .to_s
+    end
+
+    def project_root_dir(package)
+      if package.gem?
+        Ree.gem(package.gem_name).dir
+      else
+        Ree.root_dir
+      end
+    end
+  end
+end

data/lib/ree/dsl/build_package_dsl.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal  = true
+
+class Ree::BuildPackageDsl
+  include Ree::Args
+
+  attr_reader :package
+
+  # @param [Ree::PackagesFacade] packages_facade
+  # @param [Module] mod
+  # @param [Nilor[String]] path
+  def initialize(packages_facade, mod)
+    @packages_facade = packages_facade
+    @package = register_package(mod)
+  end
+
+  # @param [ArrayOf[String]] lists
+  def tags(list)
+    list.each do |tag|
+      check_arg(tag, :tag, String)
+    end
+
+    list += [@package.name.to_s]
+    list.uniq
+
+    @package.set_tags(list)
+  end
+
+  # @param [Symbol] depends_on
+  def depends_on(depends_on)
+    check_arg(depends_on, :depends_on, Symbol)
+
+    if depends_on == @package.name
+      raise_error("A package cannot depend on itself")
+    end
+
+    if @package.get_dep(depends_on)
+      raise_error("Dependent package :#{depends_on} already added for package :#{@package.name}")
+    end
+
+    package_dep = @package.set_dep(
+      Ree::PackageDep.new(depends_on)
+    )
+
+    dep_package = begin
+      @packages_facade.get_package(depends_on)
+    rescue Ree::Error
+      raise_error("Dependent package :#{depends_on} was not found in #{Ree::PACKAGES_SCHEMA_FILE}. Run `ree gen.packages_json` to update schema or fix package name")
+    end
+
+    @packages_facade.load_package_entry(dep_package.name)
+
+    package_dep
+  end
+
+  # @param [Proc] block
+  def default_links(&block)
+    raise Ree::Error.new("block missing") if !block_given?
+
+    @package.set_default_links(&block)
+  end
+
+  # @param [String] var_name
+  # @param [Nilor[String]] doc
+  def env_var(var_name, doc: nil)
+    check_arg(var_name, :env_var, String)
+    check_arg(doc, :doc, String) if doc
+
+    if @package.get_env_var(var_name)
+      raise_error("Duplicate env var '#{var_name}'")
+    end
+
+    @package.set_env_var(
+      Ree::PackageEnvVar.new(
+        var_name, doc
+      )
+    )
+  end
+
+  # @param [HashOf[Symbol, ArrayOf[Symbol]]] opts
+  def preload(opts)
+    check_arg(opts, :opts, Hash)
+
+    opts.each do |env, list|
+      check_arg(list, :object_list, Array)
+
+      list.each do |object_name|
+        check_arg(object_name, :object_name, Symbol)
+      end
+    end
+
+    @package.set_preload(opts)
+  end
+
+  private
+
+  def check_module(mod)
+    check_arg(mod, :module_name, Module)
+    module_name = mod.to_s
+    list = module_name.split('::')
+
+    if list.size != 1
+      raise Ree::Error.new("depends_on should be defined for top level modules only", :invalid_dsl_usage)
+    end
+  end
+
+  def register_package(mod)
+    check_module(mod)
+    check_arg(mod, :module, Module)
+
+    if mod.name.nil?
+      raise Ree::Error.new("package decorator should be applied to a named module", :invalid_dsl_usage)
+    end
+
+    path = Object.const_source_location(mod.name)[0].split(':').first
+    module_name = mod.to_s
+    list = module_name.split('::')
+
+    if list.size != 1
+      raise Ree::Error.new("package should be defined for top level modules only", :invalid_dsl_usage)
+    end
+
+    name_from_path = File.basename(path, ".*").to_sym
+    name = Ree::StringUtils.underscore(list[0]).to_sym
+
+    if !Ree.irb_mode? && name != name_from_path
+      raise Ree::Error.new("Package module '#{module_name}' does not correspond to package name 'name'. Fix file name or module name.")
+    end
+
+    package = @packages_facade.get_package(name, false)
+
+    if package.nil?
+      package = Ree::Package.new(Ree::VERSION, name, nil, nil, nil)
+      @packages_facade.store_package(package)
+    end
+
+    package.set_module(mod)
+    package.set_tags([name])
+
+    package.reset
+    package.set_entry_loaded
+    package.set_loaded
+
+    package
+  end
+
+  def raise_error(text, code = :invalid_dsl_usage)
+    msg = <<~DOC
+      package: :#{@package.name}
+      path: #{File.join(Ree.root_dir, @package.entry_rpath)}
+      error: #{text}
+    DOC
+
+    raise Ree::Error.new(msg, code)
+  end
+end

data/lib/ree/dsl/domain_error.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal  = true
+
+class Ree::DomainError < StandardError
+end