ree 1.0.0

data/lib/ree/object_compiler.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal  = true
+
+class Ree::ObjectCompiler
+  def initialize(packages_facade)
+    @packages_facade = packages_facade
+    @link_validator = Ree::LinkValidator.new(packages_facade)
+  end
+
+  # @param [Symbol] package_name
+  # @param [Symbol] object_name
+  # @return [Ree::Object]
+  def call(package_name, object_name)
+    @packages_facade.get_loaded_package(package_name)
+    object = @packages_facade.load_package_object(package_name, object_name)
+
+    object.set_as_compiled(true)
+    Ree.logger.debug("compile_object(:#{package_name}, :#{object_name}), object_id=#{object.object_id}")
+
+    klass = object.klass
+    links = object.links
+    eval_list = []
+
+    eval_list.push("\n# #{object.klass}")
+    indent = ""
+
+    links.each do |_|
+      eval_list.push(indent + "private attr_reader :#{_.as}")
+    end
+
+    eval_list.push("\n")
+
+    if object.singleton
+      eval_list.push(indent + "if !const_defined?(:SEMAPHORE)")
+      eval_list.push(indent + "  SEMAPHORE = Mutex.new")
+      eval_list.push(indent + "  private_constant :SEMAPHORE")
+      eval_list.push(indent + "end")
+      eval_list.push("\n")
+    end
+
+    if object.factory || object.singleton
+      eval_list.push(indent + "def self.new(**kwargs)")
+
+      if object.singleton
+        eval_list.push(indent + "  SEMAPHORE.synchronize do")
+        eval_list.push(indent + "    obj_links = #{links.map(&:as).inspect}")
+        eval_list.push(indent + "    if (obj_links & kwargs.keys).size == 0")
+        eval_list.push(indent + "      @__instance ||= begin")
+
+        if object.factory
+          eval_list.push(indent + "        super(**kwargs).#{object.factory}")
+        else
+          eval_list.push(indent + "        super(**kwargs)")
+        end
+
+        eval_list.push(indent + "      end")
+        eval_list.push(indent + "    else")
+
+        if object.factory
+          eval_list.push(indent + "      super(**kwargs).#{object.factory}")
+        else
+          eval_list.push(indent + "      super(**kwargs)")
+        end
+
+        eval_list.push(indent + "    end")
+        eval_list.push(indent + "  end")
+      else
+        eval_list.push(indent + "  super(**kwargs).#{object.factory}")
+      end
+
+      eval_list.push(indent + "end")
+    end
+
+    eval_list.push("\n")
+    eval_list.push(indent + "def initialize(**kwargs)")
+
+    indent = inc_indent(indent)
+
+    links.each do |_|
+      @link_validator.call(object, _)
+      pckg = @packages_facade.get_loaded_package(_.package_name)
+      obj = pckg.get_object(_.object_name)
+
+      @packages_facade.load_package_object(pckg.name, obj.name)
+
+      eval_list.push(indent + "@#{_.as} = kwargs[:#{_.as}] || #{obj.klass}.new(**kwargs)")
+    end
+
+    if object.after_init?
+      eval_list.push(indent + "#{object.after_init}")
+    end
+
+    if object.compiled_frozen
+      eval_list.push(indent + 'freeze')
+    end
+
+    indent = dec_indent(indent)
+
+    eval_list.push(indent + 'end')
+
+    links.each do |_|
+      pckg = @packages_facade.get_loaded_package(_.package_name)
+      obj = pckg.get_object(_.object_name)
+
+      if obj.fn?
+        eval_list.push(indent + "\nprivate def #{_.as}(*args, **kwargs, &block)")
+        indent = inc_indent(indent)
+        eval_list.push(indent + "@#{_.as}.call(*args, **kwargs, &block)")
+        indent = dec_indent(indent)
+        eval_list.push(indent + "end")
+      else
+        eval_list.push(indent + "\nprivate def #{_.as}")
+        indent = inc_indent(indent)
+        eval_list.push(indent + "@#{_.as}")
+        indent = dec_indent(indent)
+        eval_list.push(indent + "end")
+      end
+    end
+
+    indent = dec_indent(indent)
+
+    str = eval_list.join("\n")
+
+    klass.class_eval <<-ruby_eval, __FILE__, __LINE__ + 1
+      #{str}
+    ruby_eval
+
+    # compile all linked objects
+    links.each do |link|
+      pckg = @packages_facade.get_loaded_package(link.package_name)
+      obj = pckg.get_object(link.object_name)
+
+      if !obj.compiled?
+        self.call(obj.package_name, obj.name)
+      end
+    end
+
+    object
+  end
+
+  private
+
+  def inc_indent(indent)
+    indent += "  "
+  end
+
+  def dec_indent(indent)
+    indent.slice(0, indent.size - 2)
+  end
+end

data/lib/ree/package_dsl.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal  = true
+
+module Ree::PackageDSL
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  def self.extended(base)
+    base.extend(ClassMethods)
+  end
+
+  module ClassMethods
+    def package(&proc)
+      dsl = Ree::BuildPackageDsl.new(
+        Ree.container.packages_facade, self
+      )
+
+      dsl.instance_exec(&proc) if block_given?
+
+      return if dsl.package.preloaded?
+      dsl.package.set_preloaded(true)
+
+      dsl.package.preload.each do |env, list|
+        next if !Ree.preload_for?(env)
+
+        list.each do |object_name|
+          Ree.container.compile_object(
+            "#{dsl.package.name}/#{object_name}",
+          )
+        end
+      end
+    end
+  end
+end

data/lib/ree/rspec_link_dsl.rb

@@ -0,0 +1,19 @@
+module Ree::RSpecLinkDSL
+  def link(obj_name, as: nil, from:)
+    obj = Ree.container.compile(from, obj_name)
+
+    if obj.nil?
+      raise Ree::Error.new("object :#{obj_name} was not found for package :#{from}")
+    end
+    
+    as ||= obj_name
+
+    define_method as do |*args, **kwargs, &proc|
+      if obj.object?
+        obj.klass.new
+      else
+        obj.klass.new.call(*args, **kwargs, &proc)
+      end
+    end
+  end
+end

data/lib/ree/spec_runner/command_generator.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal  = true
+
+class Ree::SpecRunner::CommandGenerator
+  attr_accessor :package_name, :package_path, :spec_matcher, :spec_string_number
+
+  def initialize(package_name:, package_path:, spec_matcher:, spec_string_number:, show_output: true)
+    @package_name = package_name
+    @package_path = File.expand_path(package_path)
+    @spec_matcher = spec_matcher
+    @spec_string_number = spec_string_number
+    @output = show_output ? '$stdout' : 'File::NULL'
+  end
+
+  def spec_count
+    Dir[File.join(package_path, 'spec/**/*_spec.rb')].size
+  end
+
+  def command
+    package_spec_path = File.join(package_path, 'spec')
+    package_spec_helper = File.join(package_path, 'spec', 'spec_helper.rb')
+    matcher = ""
+
+    if spec_matcher
+      matched_file = File.expand_path(spec_matcher, package_path)
+      matcher = File.exist?(matched_file) ? matcher_with_number(matched_file, spec_string_number) : matcher_with_number(spec_matcher, spec_string_number)
+    end
+
+    "print_message(
+        '**** Package: #{package_name}  *****') \\
+          && system('cd #{Ree.root_dir} \\
+          && bundle exec rspec --color --tty #{matcher} --default-path=#{package_spec_path} --require=#{package_spec_helper}', \\
+          out: #{@output.to_s}, err: :out)"
+  end
+
+  def generate
+    Ree::SpecRunner::CommandParams.new.tap do |cp|
+      cp.package_name = package_name
+      cp.package_path = package_path
+      cp.command      = command
+      cp.spec_count   = spec_count
+    end
+  end
+
+  private
+
+  def matcher_with_number(matcher_string, string_number)
+    string_number == 0 ? matcher_string : [matcher_string, string_number].join(':')
+  end
+end

data/lib/ree/spec_runner/command_params.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal  = true
+
+class Ree::SpecRunner::CommandParams
+  attr_accessor :package_name, :package_path, :spec_matcher, :spec_count, :command, :exitstatus
+
+  def success?
+    @exitstatus == 0
+  end
+end

data/lib/ree/spec_runner/runner.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal  = true
+
+class Ree::SpecRunner::Runner
+  attr_accessor :no_specs_packages
+  attr_accessor :prepared_command_params
+
+  def initialize(path: nil, package: nil, spec_matcher: nil, show_missing_packages: true,
+                stdout: $stdout, show_output: true )
+    @package_name = package
+    @no_specs_packages = []
+    @spec_matcher = spec_matcher.to_s.split(':')[0]
+    @spec_string_number = spec_matcher.to_s.split(':')[1].to_i
+    @path = path
+    @stdout = stdout
+    @show_output = show_output
+  end
+
+  def run
+    if @spec_matcher
+      find_matched_files(@package_name)
+    end
+
+    prepare!
+    check_input_params!
+    display_missing_specs if @show_missing_packages
+    print_message view.specs_header_message if @show_missing_packages
+
+    execute_command
+  end
+
+  private
+
+  def prepare!
+    prepared_command_params = []
+    no_specs_packages = []
+    @command_params_list = []
+    prepare_command_params
+    prepare_no_specs_packages
+    prepare_command
+  end
+
+  def is_package_included?(package_name)
+    !prepared_command_params.select do |x|
+      x.package_name == package_name
+    end.empty?
+  end
+
+  def prepare_command_params
+    @prepared_command_params ||= begin
+      [
+        Ree::SpecRunner::CommandGenerator.new(
+          package_name: selected_package.name,
+          package_path: File.join(@path, selected_package.dir),
+          spec_matcher: @spec_matcher,
+          spec_string_number: @spec_string_number,
+          show_output:  @show_output
+        ).generate
+      ]
+    end
+  end
+
+  def prepare_command
+    @command_params_list += prepare_single_package_command(@package_name)
+  end
+
+  def prepare_no_specs_packages
+    prepared_command_params
+      .select { |cp| cp.spec_count == 0 }
+      .map { |cp| no_specs_packages << cp.package_name }
+  end
+
+  def prepare_single_package_command(package_name)
+    selected = prepared_command_params.detect do |cmd_params|
+      cmd_params.package_name == package_name
+    end
+    
+    prepare_commands_for_packages([selected])
+  end
+
+  def prepare_commands_for_packages(packages_command_params)
+    running_packages = packages_command_params
+      .select  { |cmd_params| cmd_params.spec_count > 0 }
+      .sort_by { |cmd_params| cmd_params.package_name }
+
+    running_packages
+  end
+
+  def execute_command
+    @command_params_list.each do |command_param|
+      eval(command_param.command);
+
+      command_param.exitstatus = $?.exitstatus
+    end
+
+    failed = @command_params_list.select {|cmd_param| !cmd_param.success?}
+
+    if failed.any?
+      total_count = @command_params_list.count
+      failed_count = failed.count
+
+      print_message("#{failed_count} of #{total_count} packages failed:")
+      print_message(failed.map(&:package_name))
+      print_message("\n")
+
+      exit(1)
+    end
+  end
+
+  def check_input_params!
+    if @package_name
+      unless is_package_included?(@package_name)
+        exit_with_message(
+          view.package_not_found_message(@package_name, prepared_command_params)
+        )
+      end
+
+      if no_specs_packages.include?(@package_name)
+        print_message(
+          view.no_specs_for_package(@package_name)
+        )
+      end
+    end
+  end
+
+  def display_missing_specs
+    if !no_specs_packages.empty?
+      print_message view.missing_specs_message(no_specs_packages)
+    end
+  end
+
+  def find_matched_files(package_name)
+    @spec_file_matches = Ree::SpecRunner::SpecFilenameMatcher.find_matches(
+      package_path: File.join(@path, selected_package.dir),
+      spec_matcher: @spec_matcher
+    )
+
+    case @spec_file_matches.size
+    when 0
+      raise Ree::Error.new("No spec were found for #{@spec_matcher}")
+    when 1
+      format_string_number = @spec_string_number == 0 ? "" : ":#{@spec_string_number}"
+      @spec_matcher = @spec_file_matches.first
+      puts "Following spec matches your input: #{@spec_matcher + format_string_number}"
+    else
+      format_spec_files = @spec_file_matches.map.with_index { |file, idx| "#{idx + 1}. #{file}" }.join("\n")
+
+      puts "Following specs match your input:"
+      puts format_spec_files
+      print "Enter space-separated file numbers, ex: '1 2': "
+      selected_files_numbers = $stdin.gets.chomp
+        .split(' ')
+        .map {|x| Integer(x) rescue nil }
+        .compact
+        .map { |n| n - 1 }
+        .reject { |n| n >= @spec_file_matches.size }
+
+
+      @spec_file_matches
+        .select
+        .with_index { |_file, idx| selected_files_numbers.include?(idx) }
+        .each do |file|
+          Ree::SpecRunner::Runner.new(
+            path: @path,
+            package: package_name,
+            spec_matcher: file,
+            show_output: @show_output,
+            stdout: @stdout
+          ).run
+      end
+
+      exit(0)
+    end
+  end
+
+  def container
+    @container = Ree.container
+  end
+
+  def selected_package
+    @selected_package ||= packages.find { |p| p.name == @package_name }
+  end
+
+  def packages
+    @packages ||= container.packages_facade.load_packages_schema.packages
+  end
+
+  def view
+    @view ||= Ree::SpecRunner::View.new
+  end
+
+  def print_message(msg)
+    @stdout.puts msg
+    true
+  end
+
+  def exit_with_message(msg)
+    print_message(msg)
+    exit 1
+  end
+end

data/lib/ree/spec_runner/spec_filename_matcher.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal  = true
+
+class Ree::SpecRunner::SpecFilenameMatcher
+  class << self
+    def find_matches(package_path:, spec_matcher:)
+      Ree::SpecRunner::SpecFilenameMatcher.new(package_path, spec_matcher).find_matches
+    end
+  end
+
+  def initialize(package_path, spec_matcher)
+    @package_path = File.expand_path(package_path)
+    @spec_matcher = spec_matcher
+  end
+
+  def find_matches
+    expected_filename = File.join(@package_path, @spec_matcher)
+
+    if File.exist?(expected_filename)
+      return Pathname.new(expected_filename).relative_path_from(Pathname.new(@package_path)).to_s.split
+    end
+
+    Dir.glob(File.join(@package_path, '**/*_spec.rb'))
+      .select { |fn| File.file?(fn) }
+      .map {|file| Pathname.new(file).relative_path_from(Pathname.new(@package_path)).to_s }
+      .grep(/#{@spec_matcher.split('').join('.*')}/)
+  end
+end

data/lib/ree/spec_runner/view.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal  = true
+
+class Ree::SpecRunner::View
+  def packages_menu(prepared_command_params)
+    prepared_command_params
+      .sort_by(&:package_path)
+      .map { |x| " - #{x.package_name} (#{x.spec_count} spec files)" }
+      .join("\n")
+  end
+
+  def package_not_found_message(package_name, prepared_command_params)
+    "Package #{package_name} not found! \nPossible packages:\n\n#{packages_menu(prepared_command_params)}"
+  end
+
+  def missing_specs_message(skipped_packages)
+    "NO SPECS FOUND FOR PACKAGES: \n#{skipped_packages.map { |x| " - #{x}" }.join("\n")}\n\n"
+  end
+
+  def skipping_specs_message(skipped_packages)
+    "FOLLOWING PACKAGES WERE SKIPPED BY .runignore FILE: \n#{skipped_packages.map { |x| " - #{x}" }.join("\n")}\n\n"
+  end
+
+  def specs_header_message
+    "**** SPECS *****"
+  end
+
+  def no_specs_for_package(package_name)
+    "Package #{package_name} has no specs to execute!"
+  end
+end

data/lib/ree/spec_runner.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal  = true
+
+module Ree
+  module SpecRunner
+    autoload :SpecFilenameMatcher, 'ree/spec_runner/spec_filename_matcher'
+    autoload :CommandGenerator, 'ree/spec_runner/command_generator'
+    autoload :CommandParams, 'ree/spec_runner/command_params'
+    autoload :Runner, 'ree/spec_runner/runner'
+    autoload :View, 'ree/spec_runner/view'
+  end
+end

data/lib/ree/templates/init/.gitignore

@@ -0,0 +1 @@
+.irb_history

data/lib/ree/templates/init/.irbrc

@@ -0,0 +1,13 @@
+class Object
+  def local_methods
+    (instance_methods - Object.instance_methods).sort
+  end
+end
+
+def link(obj_name, from:)
+  obj = Ree.container.packages_facade.get_object(from, obj_name)
+
+  define_method obj_name do |*args, **kwargs, &proc|
+    obj.klass.new.call(*args, **kwargs, &proc)
+  end
+end

data/lib/ree/templates/init/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require ./spec.init.rb

data/lib/ree/templates/init/.ruby-version

@@ -0,0 +1 @@
+<%= RUBY_VERSION %>

data/lib/ree/templates/init/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+gem 'ree'
+
+group :test do
+  gem 'rspec'
+end

data/lib/ree/templates/init/Packages.schema.json

@@ -0,0 +1 @@
+{}

data/lib/ree/templates/init/bin/console

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+require "bundler/setup"
+require "ree"
+
+Ree.init(__dir__, irb: true)

data/lib/ree/templates/init/readme.md

@@ -0,0 +1,2 @@
+# Ree usage information:
+- run `ree help` to get information about all available ree commands

data/lib/ree/templates/init/ree.setup.rb

@@ -0,0 +1,21 @@
+
+Ree.add_error_types(
+  :invalid_param,
+  :not_found,
+  :validation
+)
+
+# Switch Ree.logger to debug level
+# Ree.set_logger_debug
+
+if ENV['RUBY_ENV'] == 'test'
+  Ree.enable_contracts
+end
+
+if ENV['RUBY_ENV'] == 'production'
+  # Define preload context for registered objects
+  Ree.preload_for(:production)
+
+  # Use performance mode to load packages and registered objects based on schema files
+  Ree.set_performance_mode
+end

data/lib/ree/templates/init/spec.init.rb

@@ -0,0 +1,7 @@
+# Put global rspec configuration here. It will be loaded before each spec run.
+# Run `ree spec --help` to get usage information.
+
+require 'rspec'
+require 'ree'
+
+Ree.init(__dir__)

data/lib/ree/templates/package/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/lib/ree/templates/package/<%=package_subdir_name%>/<%=package_name%>.rb

@@ -0,0 +1,15 @@
+module <%= Ree::StringUtils.camelize(package_name) %>
+  include Ree::PackageDSL
+
+  package do
+    # Example of usage:
+    # tags ['wip']
+    # depends_on :package_name
+    # env_var 'ENV_VAR_NAME'
+    # preload(
+    #   production: [
+    #     :bean_or_fn
+    #   ]  
+    # )
+  end
+end

data/lib/ree/templates/package/bin/console

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+require "bundler/setup"
+require "ree"
+
+Ree.init(__dir__, irb: true)

data/lib/ree/templates/package/spec/package_schema_spec.rb

@@ -0,0 +1,14 @@
+RSpec.describe "<%= Ree::StringUtils.camelize(package_name) %>" do
+  it "generates package schema" do
+    require 'fileutils'
+
+    packages_schema_path = Ree.locate_packages_schema(__dir__)
+    packages_schema_dir = Pathname.new(packages_schema_path).dirname.to_s
+
+    FileUtils.cd packages_schema_dir do
+      expect(
+        system("bundle exec ree gen.package_json <%= package_name %> --silence")
+      ).to eq(true)
+    end
+  end
+end

data/lib/ree/templates/package/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+RSpec.configure do |config|
+  config.extend Ree::RSpecLinkDSL
+end