ree 1.0.0

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/exe/ree

@@ -0,0 +1,264 @@
+#!/usr/bin/env ruby
+# -*- encoding: utf-8 -*-
+require 'rubygems'
+require 'bundler/setup'
+require 'commander'
+require 'ree'
+
+class ReeCliRunner
+  TEST_FRAMEWORKS = %w[minitest rspec]
+  include Commander::Methods
+
+  def run
+    program :name, 'Ree'
+    program :version, Ree::VERSION
+    program :description, 'An enterprise ruby framework'
+    program :help, 'Author', 'Ruslan Gatiyatov'
+
+    command :"init" do |c|
+      c.syntax      = 'ree init'
+      c.description = 'generates project scaffold in a passed directory'
+      c.summary     = '> ' + c.description
+      c.example     'generate scaffold with minitest', 'ree init --test=minitest'
+      c.example     'generate scaffold with rspec',    'ree init --test=rspec'
+      c.example     'generate scaffold with irb',      'ree init --console=irb'
+      c.example     'generate scaffold with pry',      'ree init --console=pry'
+      c.option      '--test FRAMEWORK', TEST_FRAMEWORKS, "select test framework: #{TEST_FRAMEWORKS.join(", ")}"
+      c.option      '--project_path [PROJECT_ROOT_DIR]', String, 'Path for the root project dir'
+      c.action do |args, options|
+        defaults = {
+          test: "rspec",
+          console: "irb",
+          project_path: File.expand_path(Dir.pwd)
+        }
+
+        options_hash = options.__hash__
+        options_hash.delete(:trace)
+
+        if options_hash[:project_path]
+          options_hash[:project_path] = File.expand_path(options_hash[:project_path])
+        end
+
+        options_with_defaults = defaults.merge!(options_hash)
+        Ree::CLI::Init.run(**options_with_defaults)
+        Ree::CLI::GeneratePackagesSchema.run(options_with_defaults[:project_path])
+      end
+    end
+
+    command :"gen.package" do |c|
+      c.syntax      = 'ree gen.package PACKAGE_NAME [options]'
+      c.description = 'generates a package scaffold in a specified folder'
+      c.summary     = '> ' + c.description
+      c.example     "generate 'accounts' package",
+                    'ree gen.package accounts --path bc/accounts'
+      c.example     'generate events package within /some/other/path folder',
+                    'ree gen.package events --path core/domain/events --project_path /data/my_project'
+      c.example     'generate auth package without tests', 'ree gen.package auth --path subsystems/auth'
+      c.option      '--path [RELATIVE_PACKAGE_PATH]', String, 'Relative package path'
+      c.option      '--project_path [ROOT_PROJECT_DIR]', String, 'Root project dir path'
+
+      c.action do |args, options|
+        package_name = args.first.to_s.strip
+
+        if package_name.empty?
+          raise Ree::Error.new("Package name should be provided")
+        end
+
+        defaults = {
+          project_path: File.expand_path(Dir.pwd),
+          package_name: package_name,
+        }
+
+        options_hash = options.__hash__
+
+        if options_hash[:project_path]
+          options_hash[:project_path] = File.expand_path(options_hash[:project_path])
+        end
+
+        if options_hash[:path].nil?
+          raise Ree::Error.new("Path name should be provided")
+        end
+
+        options_hash.delete(:trace)
+
+        options_with_defaults = defaults.merge!(options_hash)
+
+        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],
+          include_objects: false,
+          silence: false
+        )
+      end
+    end
+
+    command :"gen.packages_json" do |c|
+      c.syntax      = 'ree gen.packages_json'
+      c.description = 'generates Packages.schema.json'
+      c.summary     = '> ' + c.description
+      c.example     'ree gen.packages_json', ''
+      c.option      '--project_path [ROOT_PROJECT_DIR]', String, 'Root project dir path'
+      c.action do |_, options|
+        options_hash = options.__hash__
+
+        if options_hash[:project_path]
+          options_hash[:project_path] = File.expand_path(options_hash[:project_path])
+        end
+
+        project_path = options_hash[:project_path] || Dir.pwd
+        Ree::CLI::GeneratePackagesSchema.run(project_path)
+      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.packages_json PACKAGE_NAME', ''
+      c.option      '--skip_objects', String, 'Skip generation of object schemas'
+      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),
+          include_objects: !options_hash.has_key?(:skip_objects),
+          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"
+      c.summary     = '> ' + c.description
+      c.example     'creating new repository_template, mapper and dao files',
+                    'ree gen.template repository_template --path infrastructure/storage'
+      c.option      '--path [RELATIVE_PATH]', String, 'Location of generated folders'
+      c.option      '--project_path [ROOT_PROJECT_DIR]', String, 'Root project dir path'
+      c.option      '--OPTION_NAME [OPTION_VALUE]', String, 'Local variables for template handler'
+      c.action do |args, options|
+        template_name = args.first || ""
+        options_hash = options.__hash__
+        options_hash.delete(:trace)
+
+        defaults = {
+          project_path: File.expand_path(Dir.pwd),
+          template_name: template_name
+        }
+
+        if options_hash[:path].nil? || options_hash[:path].empty?
+          raise Ree::Error.new('Relative path for template should be provided')
+        end
+
+        if options_hash[:project_path]
+          options_hash[:project_path] = File.expand_path(options_hash[:project_path])
+        end
+
+        options_with_defaults = defaults.merge!(options_hash)
+
+        Ree::CLI::GenerateTemplate.run(
+          template_name: options_with_defaults[:template_name],
+          project_path: options_with_defaults[:project_path],
+          local_path: options_with_defaults[:path],
+          locals: options_with_defaults
+        )
+      end
+    end
+
+    command :"exec" do |c|
+      c.syntax      = 'ree exec PACKAGE_NAME PATH_TO_EXEC [options]'
+      c.description = 'change directory to package folder and run executable bash file'
+      c.summary     = '> ' + c.description
+      c.example     "run executable file 'bin/run' for 'accounts' package",
+                    'ree exec accounts bin/run'
+      c.option      '-x', TrueClass, "run 'chmod +X' before the command"
+
+      c.action do |args, options|
+        package_name    = args[0]&.to_sym || (raise Ree::Error.new("package name should be provided"))
+        executable_path = args[1]         || (raise Ree::Error.new("executable path should be provided"))
+        run_chmod_x     = options.x
+
+        puts("Executing #{executable_path} for :#{package_name} package")
+
+        Ree.init(Dir.pwd)
+
+        package          = Ree.container.packages_facade.get_loaded_package(package_name)
+        package_abs_path = Ree::PathHelper.abs_package_dir(package)
+        exec_abs_path    = Pathname.new(package_abs_path).join(Pathname.new(executable_path)).to_s
+
+        raise Ree::Error.new("File #{exec_abs_path} not found") unless File.exists?(exec_abs_path)
+
+        system("chmod +x #{exec_abs_path}") if run_chmod_x
+        system(exec_abs_path)
+      end
+    end
+
+    command :"spec" do |c|
+      c.syntax  = "ree spec PACKAGE_NAME SPEC_MATCHER [options]"
+      c.description = "run tests for specified package"
+      c.example 'ree spec accounts', "Run specs for 'accounts' package"
+      c.example 'ree spec -p accounts -p roles', 'Run specs for several packages'
+      c.example 'ree spec accounts welcome_email:42', 'Run specific spec from specified package using spec matcher'
+      c.example 'ree spec --tag wip', 'Run specs for packages which have "wip" tag'
+      c.option '--project_path [ROOT_DIR]', String, 'Root project dir path'
+      c.option '--tag TAG_NAME', String, 'Run specs for packages with specified tag'
+      c.option '--with_children', TrueClass, 'Run specs for all children dependent packages'
+      c.option '--with_ancestors', TrueClass, 'Run specs for all ancestors dependent packages'
+      c.option '-p PACKAGE_NAME', '--package PACKAGE_NAME', String, 'Package names' do |o|
+        @package_names ||= []
+        @package_names << o.to_sym
+      end
+
+      c.action do |args, options|
+        @package_names ||= []
+
+        package_name = args[0]&.to_sym
+        spec_matcher = args[1]
+
+        options_hash = options.__hash__
+        options_hash.delete(:trace)
+
+        if options_hash[:project_path]
+          options_hash[:project_path] = File.expand_path(options_hash[:project_path])
+        end
+
+        if package_name
+          @package_names ||= []
+          @package_names << package_name
+        end
+
+        if package_name.nil? && options_hash.keys.empty? && \
+           spec_matcher.nil? && @package_names.empty?
+          @run_all = true
+        end
+
+        Ree::CLI::SpecRunner.run(
+          package_names: @package_names,
+          spec_matcher: spec_matcher,
+          tag_name: options_hash[:tag],
+          with_children: options_hash[:with_children],
+          with_ancestors: options_hash[:with_ancestors],
+          run_all: @run_all,
+          path: options_hash[:project_path] || File.expand_path(Dir.pwd)
+        )
+      end
+    end
+
+    run!
+  end
+end
+
+ReeCliRunner.new.run

data/lib/ree/args.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal  = true
+
+module Ree::Args
+  def check_arg(value, name, klass)
+    if !value.is_a?(klass)
+      raise Ree::Error.new(
+        ":#{name} should be a #{klass}. Got #{value.class}: #{Ree::StringUtils.truncate(value.inspect)}",
+        :invalid_arg
+      )
+    end
+  end
+
+  def check_bool(value, name)
+    check_arg_any(value, name, [TrueClass, FalseClass])
+  end
+
+  def check_arg_array_of(value, name, klass)
+    if !value.is_a?(Array) && value.detect { |_| !_.is_a?(Symbol)}
+      raise Ree::Error.new(":#{name} should be array of #{klass.inspect}. Got #{value.class}: #{Ree::StringUtils.truncate(value.inspect)}", :invalid_arg)
+    end
+  end
+
+  def check_arg_any(value, name, klasses)
+    if !klasses.detect {|klass| value.is_a?(klass)}
+      raise Ree::Error.new(":#{name} should be any of #{klasses.inspect}", :invalid_arg)
+    end
+  end
+
+  def not_nil(value, name)
+    if value.nil?
+      raise Ree::Error(":#{name} should not be nil", :invalid_arg)
+    end
+  end
+end

data/lib/ree/bean_dsl.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Ree::BeanDSL
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  def self.extended(base)
+    base.extend(ClassMethods)
+  end
+
+  module ClassMethods
+    def bean(name, &proc)
+      dsl = Ree::ObjectDsl.new(
+        Ree.container.packages_facade, name, self, :object
+      )
+
+      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/cli/generate_package.rb

@@ -0,0 +1,18 @@
+module Ree
+  module CLI
+    class GeneratePackage
+      class << self
+        def run(package_name:, project_path:, path:, locals: {}, stdout: $stdout)
+          generated_files_list = Ree::Gen::Package.generate(
+            project_path: project_path,
+            local_path:   path,
+            package_name: package_name,
+            locals:       locals
+          )
+  
+          generated_files_list.compact.each { |file| stdout.puts "Generated: #{file}" }
+        end
+      end
+    end
+  end
+end

data/lib/ree/cli/generate_package_schema.rb

@@ -0,0 +1,54 @@
+require 'fileutils'
+
+module Ree
+  module CLI
+    class GeneratePackageSchema
+      class << self
+        def run(package_name:, project_path:, include_objects: false, 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
+
+          Ree.container.packages_facade.load_packages_schema
+          package = Ree.load_package(package_name)
+          Ree.container.packages_facade.write_package_schema(package_name)
+
+          package = Ree.container.packages_facade.get_package(package_name)
+          schema_path = Ree::PathHelper.abs_package_schema_path(package)
+
+          if include_objects
+            schemas_path = Ree::PathHelper.abs_package_object_schemas_path(package)
+
+            FileUtils.rm_rf(schemas_path)
+            FileUtils.mkdir_p(schemas_path)
+
+            package.objects.each do |object|
+              Ree.write_object_schema(package.name, object.name)
+
+              path = Ree::PathHelper.abs_object_schema_path(object)
+
+              puts("  #{object.name}: #{path}") if !silence
+            end
+          end
+
+          puts("output: #{schema_path}") if !silence
+          puts("done") if !silence
+        end
+      end
+    end
+  end
+end

data/lib/ree/cli/generate_packages_schema.rb

@@ -0,0 +1,17 @@
+module Ree
+  module CLI
+    class GeneratePackagesSchema
+      class << self
+        def run(project_path)
+          Ree.init(project_path)
+
+          puts("Generating Packages.schema.json")
+          Ree::PackagesFacade.write_packages_schema
+
+          puts("output: #{Ree.packages_schema_path}")
+          puts("done")
+        end
+      end
+    end
+  end
+end

data/lib/ree/cli/generate_template.rb

@@ -0,0 +1,20 @@
+module Ree
+  module CLI
+    class GenerateTemplate
+      class << self
+        def run(template_name:, project_path:, local_path:, locals:)
+          generated_files_list = Ree::TemplateHandler.generate(
+            template_name: template_name,
+            project_path: project_path,
+            local_path: local_path,
+            locals: locals
+          )
+  
+          generated_files_list.compact.each { |file| puts("Generated: #{file}") }
+
+          puts("done")
+        end
+      end
+    end
+  end
+end

data/lib/ree/cli/init.rb

@@ -0,0 +1,22 @@
+module Ree
+  module CLI
+    class Init
+      class << self
+        def run(project_path:, test:, console:, stdout: $stdout)
+          generated_files_list = Ree::Gen::Init.generate(
+            project_path: project_path,
+            test: test,
+            console: console,
+            stdout: stdout
+          )
+  
+          generated_files_list.compact.each { |file| stdout.puts "Generated: #{file}" }
+        rescue Errno::ENOENT => e
+          stdout.puts "Error occurred. Possible reasons:\n #{project_path} not found. Please run on empty directory \n#{e.inspect}"
+        rescue Ree::Error => e
+          stdout.puts e.message
+        end
+      end
+    end
+  end
+end

data/lib/ree/cli/spec_runner.rb

@@ -0,0 +1,184 @@
+require 'set'
+
+module Ree
+  module CLI
+    class SpecRunner
+      attr_reader :packages_to_run
+
+      class << self
+        def run(path:, package_names:, spec_matcher:, tag_name:,
+                with_children:, with_ancestors:, run_all: false)
+          SpecRunner.new(
+            package_names: package_names,
+            spec_matcher: spec_matcher,
+            tag_name: tag_name,
+            with_children: with_children,
+            with_ancestors: with_ancestors,
+            path: path,
+            run_all: run_all
+          ).run
+        end
+      end
+
+      def initialize(package_names:, spec_matcher:, tag_name:, with_children:,
+                     with_ancestors:, run_all: false, path:, stdout: STDOUT)
+        @package_names = package_names || []
+        @packages_to_run = @package_names
+        @spec_matcher = spec_matcher
+        @tag_name = tag_name
+        @with_children = with_children
+        @with_ancestors = with_ancestors
+        @run_all = run_all
+        @path = path
+        @stdout = stdout
+      end
+
+      def run
+        schema_path = Ree.locate_packages_schema(@path)
+        schema_dir = Pathname.new(schema_path).dirname.to_s
+
+        Ree.init(schema_dir)
+
+        unless non_existent_packages.empty?
+          non_existent_packages.map do |pack|
+            puts "Package #{pack} not found"
+            @package_names.delete(pack)
+          end
+        end
+
+        if @tag_name
+          puts "Trying to find packages with tag \"#{@tag_name}\"..."
+
+          tagged_packages = find_tagged_packages
+
+          if tagged_packages.empty?
+            puts "No packages found with tag #{@tag_name}"
+          end
+
+          @packages_to_run.push(*tagged_packages)
+        end
+
+        if @with_children
+          children_packages = @package_names.map do |package_name|
+            puts "Trying to find children packages for #{package_name}"
+
+            find_children_packages(package_name)
+          end
+
+          @packages_to_run.push(*children_packages)
+        end
+
+        if @with_ancestors
+          ancestors_packages = @package_names.map do |package_name|
+            puts "Trying to find ancestors packages for #{package_name}"
+
+            find_ancestors_packages(package_name)
+          end
+
+          @packages_to_run.push(*ancestors_packages)
+        end
+
+        if @run_all
+          puts "Running specs for all packages..."
+
+          @packages_to_run.push(*packages.map(&:name))
+        end
+
+        @packages_to_run = @packages_to_run.flatten.uniq
+
+        if @packages_to_run.empty?
+          puts "No packages found with specified options"
+        end
+
+        @packages_to_run.each do |package|
+          ree_package = Ree.container.packages_facade.get_package(package)
+
+          Ree::SpecRunner::Runner.new(
+            path: Ree::PathHelper.project_root_dir(ree_package),
+            package: package,
+            spec_matcher: @spec_matcher,
+            stdout: $stdout
+          ).run
+        end
+      end
+
+      private
+
+      def project_packages(packages)
+        packages.reject(&:gem?)
+      end
+      
+      def non_existent_packages
+        @package_names ? @package_names - packages.map(&:name) : []
+      end
+
+      def find_tagged_packages
+        names = packages.map(&:name)
+
+        names.select do |package_name|
+          package = container.packages_facade.read_package_schema_json(package_name)
+          package.tags.include?(@tag_name)
+        end.compact
+      end
+
+      def find_children_packages(package_name)
+        recursively_find_children_packages(package_name)
+      end
+
+      def find_ancestors_packages(package_name)
+        recursively_find_ancestor_packages(package_name)
+      end
+
+      def container
+        @container = Ree.container
+      end
+
+      def packages
+        @packages ||=  project_packages(
+          container.packages_facade.load_packages_schema.packages
+        )
+      end
+
+      def packages_set
+        @packages_set ||= Set.new(packages.map(&:name))
+      end
+
+      def recursively_find_children_packages(package_name, acc = [])
+        package = container.load_package(package_name)
+
+        unless acc.include?(package.name)
+          acc << package.name
+          
+          package.deps.map(&:name).each do |pack|
+            next if !packages_set.include?(pack)
+            recursively_find_children_packages(pack, acc)
+          end
+        end
+
+        acc
+      end
+
+      def recursively_find_ancestor_packages(package_name, all_packages: packages, acc: Set.new([package_name]), count: 0)
+        parents = package_parents(package_name, all_packages)
+
+        all_packages = all_packages.reject { |pack| parents.include?(pack.name) }
+        return acc.to_a if parents.empty?
+
+        parents.map { |pa| acc.add(pa) }
+
+        parents.each do |parent|
+          recursively_find_ancestor_packages(parent, all_packages: all_packages, acc: acc.flatten, count: count + 1).map { |e| acc.add(e) }
+        end
+
+        acc.to_a
+      end
+
+      def package_parents(package_name, packages)
+        packages.map do |pack|
+          package = container.load_package(pack.name)
+          pack.name if package.deps.map(&:name).include?(package_name)
+        end.compact
+      end
+    end
+  end
+end

data/lib/ree/cli.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal  = true
+
+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 :SpecRunner, 'ree/cli/spec_runner'
+  end
+end