ree 1.0.0

data/lib/ree/facades/packages_facade.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal  = true
+
+class Ree::PackagesFacade
+  include Ree::Args
+
+  attr_reader :packages_store, :package_loader
+
+  def initialize
+    load_packages_schema
+    @package_loader = Ree::PackageLoader.new(@packages_store)
+  end
+
+  class << self
+    def write_packages_schema
+      Ree.logger.debug("write_packages_schema")
+      Ree::PackagesSchemaBuilder.new.call
+    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
+  end
+
+  # @param [Symbol] package_name
+  # @param [Symbol] object_name
+  # @return [Ree::Object]
+  def get_object(package_name, object_name)
+    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
+
+  # @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)
+      Ree::PackageSchemaBuilder.new.call(package, schema_path)
+    end
+  end
+
+  # @param [Symbol] package_name
+  # @param [Symbol] object_name
+  # @return [String]
+  def write_object_schema(package_name, object_name)
+    Ree.logger.debug("write_object_schema(package_name: #{package_name}, object_name: #{object_name})")
+    object = get_object(package_name, object_name)
+
+    if !object || (object && !object&.schema_rpath)
+      raise Ree::Error.new("Object :#{object_name} schema path not found")
+    end
+
+    schema_path = Ree::PathHelper.abs_object_schema_path(object)
+
+    Ree::ObjectSchemaBuilder.new.call(object, schema_path)
+  end
+
+  # @param [Symbol] package_name
+  # @return nil
+  def load_package_entry(package_name)
+    package = @packages_store.get(package_name)
+    return if package.loaded?
+
+    Ree.logger.debug("load_package_entry(:#{package_name})")
+
+    load_file(
+      Ree::PathHelper.abs_package_entry_path(package),
+      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
+      raise Ree::Error.new("object :#{object_name} from :#{package_name} was not found")
+    end
+
+    Ree.logger.debug("load_package_object(:#{package_name}, :#{object_name})")
+
+    if object.rpath
+      object_path = Ree::PathHelper.abs_object_path(object)
+      load_file(object_path, package_name)
+    end
+
+    object
+  end
+
+  # @param [Symbol] package_name
+  # @return [Ree::Package]
+  def load_entire_package(package_name)
+    @package_loader.call(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)
+  end
+
+  # @return [Ree::PackagesStore]
+  def load_packages_schema
+    Ree.logger.debug("load_packages_schema: #{self.object_id}")
+    @packages_store = Ree::PackagesSchemaLoader.new.call(Ree.packages_schema_path, @packages_store)
+
+    Ree.gems.each do |gem|
+      Ree::PackagesSchemaLoader.new.call(
+        gem.packages_schema_path, @packages_store, gem.name
+      )
+    end
+
+    @packages_store
+  end
+
+  # @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
+  end
+
+  # @param [Ree::Package] package
+  # @return [Ree::Package]
+  def store_package(package)
+    @packages_store.add_package(package)
+  end
+
+  # @param [String] path
+  # @param [Symbol] package_name
+  # @return [nil]
+  def load_file(path, package_name)
+    @package_loader.load_file(path, package_name)
+  end
+end

data/lib/ree/fn_dsl.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Ree::FnDSL
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  def self.extended(base)
+    base.extend(ClassMethods)
+  end
+
+  module ClassMethods
+    def fn(name, &proc)
+      dsl = Ree::ObjectDsl.new(
+        Ree.container.packages_facade, name, self, :fn
+      )
+
+      dsl.instance_exec(&proc) if block_given?
+      dsl.object.set_as_compiled(false)
+
+      Ree.container.compile(dsl.package, name)
+    end
+  end
+end

data/lib/ree/gen/init.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal  = true
+
+require 'fileutils'
+require 'pathname'
+
+module Ree
+  module Gen
+    class Init
+      TEMPLATE_NAME        = 'init'
+      INIT_PATH            = './'
+      LOCAL_TEMPLATES_PATH = '.ree/templates'
+
+      class << self
+        def generate(project_path:, test: 'rspec', console: 'irb', stdout: STDOUT)
+          Ree::Gen::Init.new(project_path, test, console, stdout).generate
+        end
+      end
+
+      def initialize(project_path, test, console, stdout)
+        @project_path      = project_path
+        @test              = test
+        @console           = console
+        @template_detector = Ree::TemplateDetector.new(project_path)
+        @stdout            = stdout
+      end
+
+      def generate
+        if @project_path.nil? || @project_path.empty?
+          raise Ree::Error.new("Project folder not specified. Type path to ree project, ex: 'ree init .'")
+        end
+
+        if !Dir.exist?(@project_path)
+          raise Ree::Error.new("#{@project_path} doesn't exist. Initialize new ree project with existing directory")
+        end
+
+        if File.exist?(File.join(@project_path, Ree::PACKAGES_SCHEMA_FILE))
+          raise Ree::Error.new("#{@project_path} has already #{Ree::PACKAGES_SCHEMA_FILE}")
+        end
+
+        generated_files = Ree::TemplateHandler.generate(
+          template_name: TEMPLATE_NAME,
+          project_path: @project_path,
+          local_path: INIT_PATH,
+          stdout: @stdout
+        )
+
+        FileUtils.mkdir_p(local_templates_path)
+        
+        FileUtils.cp_r(
+          @template_detector.gem_template_folder('package'),
+          File.dirname(@template_detector.project_template_folder('package'))
+        )
+
+        generated_files
+      end
+
+      private
+
+      def local_templates_path
+        File.join(@project_path, LOCAL_TEMPLATES_PATH)
+      end
+    end
+  end
+end

data/lib/ree/gen/package.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal  = true
+
+require 'fileutils'
+require 'pathname'
+
+module Ree
+  module Gen
+    class Package
+      TEMPLATE_NAME = 'package'
+
+      class << self
+        def generate(package_name:, project_path:, local_path:, locals: {})
+          Ree::Gen::Package.new(package_name, project_path, local_path, locals).create
+        end
+      end
+
+      def initialize(package_name, project_path, local_path, locals = {})
+        @project_path = project_path
+        @package_name = package_name
+        @local_path = local_path
+        @locals = locals
+        @schema = get_schema
+      end
+
+      def create
+        if Dir.exist?(File.join(Ree.root_dir, @local_path))
+          raise Ree::Error.new("Package directory #{@local_path} already exists") 
+        end
+
+        if @package_name.nil? || @package_name.empty?
+          raise Ree::Error.new('Package name was not specified') 
+        end
+
+        if @schema.packages.map(&:name).include?(@package_name)
+          raise Ree::Error.new('Package already exists') 
+        end
+
+        generated_files = Ree::TemplateHandler.generate(
+          template_name: TEMPLATE_NAME,
+          project_path: @project_path,
+          local_path: @local_path,
+          locals: { package_name: @package_name, local_path: @local_path }.merge(@locals)
+        )
+
+        generated_files
+      end
+
+      def get_schema
+        @schema ||= begin
+          Ree.init(@project_path)
+          Ree.container.packages_facade.load_packages_schema
+        end
+      end
+    end
+  end
+end

data/lib/ree/gen.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal  = true
+
+module Ree
+  module Gen
+    autoload :Init, 'ree/gen/init'
+    autoload :Package, 'ree/gen/package'
+  end
+end

data/lib/ree/handlers/template_handler.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal  = true
+
+require 'pathname'
+require 'fileutils'
+
+class Ree::TemplateHandler
+  REJECTED_TEMPLATE_FILES   = %W(.DS_Store)
+  NOT_HANDLED_TEMPLATES_EXT = %W(.erb)
+
+  class << self
+    def generate(template_name:, local_path:, project_path:, locals: {}, 
+                stdout: STDOUT, stdin: STDIN)
+
+      Ree::TemplateHandler.new(
+        template_name: template_name.to_s,
+        local_path: local_path,
+        project_path: project_path,
+        locals: locals,
+        stdout: stdout,
+        stdin: stdin
+      ).generate
+    end
+  end
+
+  def initialize(
+    template_name:,
+    local_path:,
+    project_path:,
+    locals:,
+    stdout:,
+    stdin:
+  )
+
+    @template_name = template_name
+    @local_path = local_path
+    @project_path = project_path
+    @missing_variables = []
+    @stdout = stdout
+    @stdin = stdin
+    default_locals = { package_subdir_name: 'package' }
+    @locals = default_locals.merge(locals)
+  end
+
+  def generate
+    project_path = @project_path
+    template_detector = Ree::TemplateDetector.new(project_path)
+
+    @template_directory    = template_detector.detect_template_folder(@template_name)
+    @destination_directory = File.join(project_path, @local_path)
+
+    template_files_list = Dir
+      .glob(File.join(@template_directory, '**', '*'), File::FNM_DOTMATCH)
+      .reject { |path| REJECTED_TEMPLATE_FILES.include? File.basename(path)  }
+
+    template_files_list.each do |path|
+      @missing_variables.concat(
+        Ree::TemplateRenderer.get_undefined_variables(get_destination_path(path), @locals)
+      )
+
+      if handle_file_content?(path)
+        @missing_variables.concat(
+          Ree::TemplateRenderer.get_undefined_variables(File.read(path), @locals)
+        )
+      end
+    end
+
+    if @missing_variables.any?
+      @missing_variables.uniq!
+
+      @stdout.puts "Undefined variables were found:"
+      @missing_variables.size.times { |t| @stdout.puts "  #{t+1}. #{@missing_variables[t]}" }
+
+      @missing_variables.each do |var|
+        @stdout.print "Type value for '#{var}': "
+        @locals[var] = @stdin.gets.chomp
+      end
+    end
+
+    template_files_list.map! do |path|
+      rendered_abs_path = Ree::TemplateRenderer.handle(get_destination_path(path), @locals)
+      rendered_rel_path = Pathname.new(rendered_abs_path).relative_path_from Pathname.new(project_path)
+
+      if File.file?(rendered_abs_path) && File.exists?(rendered_abs_path)
+        @stdout.puts "Warning! #{rendered_rel_path} already exists. Skipping file creation..."
+        next
+      end
+
+      if File.directory?(path)
+        FileUtils.mkdir_p(rendered_abs_path)
+        next
+      end
+
+      rendered_file_content = handle_file_content?(path) ?
+        Ree::TemplateRenderer.handle(File.read(path), @locals) :
+        File.read(path)
+
+      FileUtils.mkdir_p(File.dirname(rendered_abs_path))
+      File.open(rendered_abs_path, 'w') { |f| f.write rendered_file_content }
+
+      rendered_rel_path
+    end
+
+    template_files_list.compact
+  end
+
+  private
+
+  def get_destination_path(file)
+    return nil unless defined? @template_directory && defined? @destination_directory
+
+    template_rel_path = Pathname.new(file).relative_path_from Pathname.new(@template_directory)
+    File.join(@destination_directory, template_rel_path)
+  end
+
+  def handle_file_content?(path)
+    File.file?(path) && !NOT_HANDLED_TEMPLATES_EXT.include?(File.extname(path))
+  end
+end

data/lib/ree/link_dsl.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+module Ree::LinkDSL
+  def self.included(base)
+    validate(base)
+    base.extend(ClassMethods)
+  end
+
+  def self.extended(base)
+    validate(base)
+    base.extend(ClassMethods)
+  end
+
+  def self.validate(base)
+    if !base.is_a?(Class)
+      raise ArgumentError, "Ree::LinkDSL should be included to named classed only"
+    end
+
+    if self.name.nil?
+      raise ArgumentError, "LinkDSL does not support anonymous classes"
+    end
+  end
+
+  module ClassMethods
+    include Ree::Args
+
+    def link(*args, **kwargs)
+      if args.first.is_a?(Symbol)
+        _link_object(*args, **kwargs)
+      elsif args.first.is_a?(String)
+        _link_file(args[0], args[1])
+      else
+        _raise_error("Invalid link DSL usage. Args should be Hash or String")
+      end
+    end
+
+    private
+
+    # @param [Symbol] object_name
+    # @param [Nilor[Symbol]] as
+    # @param [Nilor[Symbol]] from
+    # @param [Nilor[ArrayOf[Symbol]]] methods
+    # @param [Nilor[Proc]] import
+    def _link_object(object_name, as: nil, from: nil, methods: nil, import: nil)
+      check_arg(object_name, :object_name, Symbol)
+      check_arg(as, :as, Symbol) if as
+      check_arg(from, :from, Symbol) if from
+      check_arg(import, :import, Proc) if import
+      check_arg_array_of(methods, :methods, Symbol) if methods
+
+      package_name = Ree::StringUtils.underscore(self.name.split('::').first).to_sym
+      link_package_name = from.nil? ? package_name : from
+      link_object_name = object_name
+      link_as = as ? as : object_name
+
+      _check_package_dependency_added(link_package_name, package_name)
+
+      if import
+        Ree::LinkImportBuilder
+          .new(Ree.container.packages_facade)
+          .build(
+            self,
+            link_package_name,
+            link_object_name,
+            import
+          )
+      end
+
+      obj = Ree
+        .container
+        .packages_facade
+        .load_package_object(link_package_name, link_object_name)
+
+      if obj.fn?
+        self.class_eval %Q(
+          private def _#{link_as}
+            @#{link_as} ||= #{obj.klass}.new
+          end
+
+          private def #{link_as}(*args, **kwargs, &block)
+            _#{link_as}.call(*args, **kwargs, &block)
+          end
+        )
+      else
+        self.class_eval %Q(
+          private def #{link_as}
+            @#{link_as} ||= #{obj.klass}.new
+          end
+        )
+      end
+    end
+
+    # @param [String] path Relative package file path ('accounts/entities/user')
+    # @param [Proc] proc Import constants proc
+    def _link_file(path, import_proc = nil)
+      check_arg(import_proc, :import, Proc) if import_proc
+
+      list = path.split('/')
+      package_name = File.basename(list[0], ".*").to_sym
+      current_package_name = Ree::StringUtils.underscore(self.name.split('::').first).to_sym
+
+      _check_package_dependency_added(package_name, current_package_name)
+
+      Ree.container.packages_facade.load_package_entry(package_name)
+      package = Ree.container.packages_facade.get_package(package_name)
+
+      file_path = File.join(
+        Ree::PathHelper.abs_package_dir(package),
+        Ree::PACKAGE, path
+      )
+
+      if !File.exists?(file_path)
+        file_path = "#{file_path}.rb"
+
+        if !File.exists?(file_path)
+          _raise_error("Unable to link '#{path}'. File not found #{file_path}")
+        end
+      end
+
+      Ree.container.packages_facade.load_file(file_path, package.name)
+
+      const_list = path.split('/').map { |_| Ree::StringUtils.camelize(_) }
+      const_short = [const_list[0], const_list.last].join("::")
+      const_long = const_list.join("::")
+
+      file_const = if Object.const_defined?(const_long)
+        Object.const_get(const_long)
+      elsif Object.const_defined?(const_short)
+        Object.const_get(const_short)
+      else
+        _raise_error("Unable to link '#{path}'. #{const_long} or #{const_short} was not defined in #{file_path}")
+      end
+
+      if import_proc
+        Ree::LinkImportBuilder
+          .new(Ree.container.packages_facade)
+          .build_for_const(
+            self,
+            file_const,
+            import_proc
+          )
+      end
+
+      nil
+    end
+
+    def _raise_error(text, code = :invalid_dsl_usage)
+      msg = <<~DOC
+        object: :#{@object.name}
+        path: #{Ree::PathHelper.abs_object_path(@object)}
+        error: #{text}
+      DOC
+
+      raise Ree::Error.new(msg, code)
+    end
+
+    def _check_package_dependency_added(package_name, current_package_name)
+      return if package_name == current_package_name
+
+      facade = Ree.container.packages_facade
+      facade.load_package_entry(package_name)
+      facade.load_package_entry(current_package_name)
+
+      current_package = facade.get_package(current_package_name)
+
+      dep_package = current_package.deps.detect do |d|
+        d.name == package_name
+      end
+
+      if dep_package.nil?
+        raise_error("Package :#{package_name} is not added as dependency for :#{current_package_name} package\npackage path: #{File.join(Ree.root_dir, current_package)}")
+      end
+    end
+  end
+end