calificador 0.1.0

data/lib/calificador/spec/class_method_context.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+using Calificador::Util::CoreExtensions
+
+module Calificador
+  module Spec
+    # Context that describes an instance method
+    class ClassMethodContext < BasicContext
+      class Dsl < BasicContext::Dsl
+      end
+
+      attr_reader :method
+
+      def initialize(parent:, method:, description: nil)
+        super(
+          parent: parent,
+          subject_key: parent.subject_key,
+          description: description,
+          overrides: {}
+        )
+
+        @method = method
+      end
+
+      def separate_description_by_space?
+        @parent && !@parent.is_a?(ExamineContext)
+      end
+
+      def create_subject(environment:, subject_key:)
+        subject_key.type
+      end
+
+      def create_result(subject:, arguments:, options:, block:)
+        if options.empty?
+          subject.send(@method, *arguments, &block)
+        else
+          subject.send(@method, *arguments, **options, &block)
+        end
+      end
+    end
+  end
+end

data/lib/calificador/spec/condition_context.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Calificador
+  module Spec
+    class ConditionContext < BasicContext
+      class Dsl < BasicContext::Dsl
+      end
+    end
+  end
+end

data/lib/calificador/spec/examine_context.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+using Calificador::Util::CoreExtensions
+
+module Calificador
+  module Spec
+    class ExamineContext < BasicContext
+      class Dsl < BasicContext::Dsl
+      end
+
+      def initialize(parent:, subject_key:, description:, overrides: {})
+        super(
+          parent: parent,
+          description: description,
+          subject_key: subject_key,
+          overrides: overrides,
+        )
+      end
+
+      def create_subject(environment:, subject_key:)
+        environment.create_object(key: subject_key)
+      end
+
+      def subtree_root?
+        true
+      end
+    end
+  end
+end

data/lib/calificador/spec/instance_method_context.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+using Calificador::Util::CoreExtensions
+
+module Calificador
+  module Spec
+    # Context that describes an instance method
+    class InstanceMethodContext < BasicContext
+      class Dsl < BasicContext::Dsl
+      end
+
+      attr_reader :method
+
+      def initialize(parent:, method:, description: nil)
+        super(
+          parent: parent,
+          subject_key: parent.subject_key,
+          description: description,
+          overrides: {}
+        )
+
+        @method = method
+      end
+
+      def create_result(subject:, arguments:, options:, block:)
+        if options.empty?
+          subject.send(@method, *arguments, &block)
+        else
+          subject.send(@method, *arguments, **options, &block)
+        end
+      end
+
+      def separate_description_by_space?
+        @parent && !@parent.is_a?(ExamineContext)
+      end
+    end
+  end
+end

data/lib/calificador/spec/test_environment.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+using Calificador::Util::CoreExtensions
+
+module Calificador
+  module Spec
+    # Environment to run test method
+    class TestEnvironment
+      def initialize(test:, context:)
+        @test = test
+        @context = context
+        @subject = MISSING
+        @call_arguments = []
+        @call_options = {}
+        @call_block = nil
+        @call_result = MISSING
+        @created_objects = {}
+        @current_assertor = nil
+      end
+
+      def subject(value = MISSING)
+        if value.equal?(MISSING)
+          if @subject.equal?(MISSING)
+            @call_result = MISSING
+            @subject = @context.create_subject(environment: self, subject_key: @context.subject_key)
+          end
+        else
+          @call_result = MISSING
+          @subject = value
+        end
+
+        @subject
+      end
+
+      def arguments(*arguments, **options, &block)
+        @call_arguments = arguments.nil? ? [] : arguments
+        @call_options = options.nil? ? {} : options
+        @call_block = block
+        @call_result = MISSING
+        nil
+      end
+
+      def call(*arguments, **options, &block)
+        options.empty? ? arguments(*arguments, &block) : arguments(*arguments, **options, &block)
+        result
+      end
+
+      def result
+        if @call_result == MISSING
+          @call_result = @context.create_result(
+            subject: subject,
+            arguments: @call_arguments,
+            options: @call_options,
+            block: @call_block
+          )
+        end
+
+        @call_result
+      end
+
+      def create(type, trait = nil)
+        create_object(key: Key[type, trait])
+      end
+
+      def assert(&block)
+        @current_assertor&.__check_triggered
+
+        @current_assertor = Assertor.new(test: @test, block: block || __default_assert_block)
+      end
+
+      def refute(&block)
+        @current_assertor&.__check_triggered
+
+        @current_assertor = Assertor.new(test: @test, negated: true, block: block || __default_assert_block)
+      end
+
+      def respond_to_missing?(method, include_all)
+        @context.lookup_named_factory(name: method) || super
+      end
+
+      def method_missing(method, *arguments, **options, &block)
+        factory = @context.lookup_named_factory(name: method)
+
+        if factory
+          create_object(key: factory.key)
+        else
+          super
+        end
+      end
+
+      def create_object(key:)
+        @created_objects.fetch(key) do
+          factory = @context.lookup_factory(key: key)
+
+          object = if factory.nil?
+            raise(KeyError, "No factory found for #{key}") if key.trait != Key::DEFAULT_TRAIT
+
+            constructor = key.type.method(:new)
+            constructor.invoke
+          else
+            factory.create(context: self)
+          end
+
+          @created_objects[key] = object
+        end
+      end
+
+      def __done
+        @current_assertor&.__check_triggered
+      end
+
+      protected
+
+      def __default_assert_block
+        lambda do
+          result
+        end
+      end
+
+      # def __pass(message = nil)
+      #   @test.pass(message)
+      # end
+
+      # def __flunk(message = nil)
+      #   @test.flunk(message)
+      # end
+
+      # def __assert(condition, message = nil)
+      #   @test.assert(condition, message)
+      # end
+
+      # def __refute(condition, message = nil)
+      #   @test.refute(condition, message)
+      # end
+
+      # def __exception_details(exception, message)
+      #   @test.exception_details(exception, message)
+      # end
+    end
+  end
+end

data/lib/calificador/spec/test_method.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+using Calificador::Util::CoreExtensions
+
+module Calificador
+  module Spec
+    # Factory class
+    class TestMethod < BasicContext
+      class Dsl < BasicContext::Dsl
+        def body(&block)
+          delegate.body = block
+        end
+      end
+
+      attr_reader :body, :expected_to_fail
+
+      def initialize(parent:, subject_key:, description:, overrides:, expected_to_fail: false, body:)
+        super(parent: parent, subject_key: subject_key, description: description, overrides: overrides)
+
+        @body = body
+        @expected_to_fail = expected_to_fail
+      end
+
+      def setup
+        test_method = self # rubocop:disable Lint/UselessAssignment
+        test_method_name = method_name # rubocop:disable Lint/UselessAssignment
+        file, line_number = @body.source_location
+
+        test_class.class_eval(<<~METHOD, file, line_number)
+          define_method(test_method_name) do
+            __run_test(test_method: test_method)
+          end
+        METHOD
+
+        super
+      end
+
+      def method_name
+        @method_name ||= "test_: #{full_description}"
+      end
+
+      def run_test(test:)
+        body = self.body
+        environment = TestEnvironment.new(test: test, context: self)
+
+        if expected_to_fail
+          passed = begin
+            environment.instance_exec(&body)
+            true
+          rescue ::Minitest::Assertion => e
+            test.pass(e.message)
+            false
+          end
+
+          test.flunk("Expected test to fail") if passed
+        else
+          environment.instance_exec(&body)
+        end
+
+        environment.__done
+      end
+    end
+  end
+end

data/lib/calificador/spec/test_root.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+using Calificador::Util::CoreExtensions
+
+module Calificador
+  module Spec
+    class TestRoot < ExamineContext
+      class Dsl < ExamineContext::Dsl
+        def body(&block)
+          delegate.body = block
+        end
+      end
+
+      attr_accessor :test_class
+
+      def initialize(test_class:, subject_key:, description:, &body)
+        super(parent: nil, subject_key: subject_key, description: description, overrides: {})
+
+        @test_class = test_class
+        @body = body
+      end
+
+      def body=(&block)
+        test_class.class_eval(&block)
+      end
+
+      def setup
+        setup_body
+
+        super
+      end
+
+      def create_result(subject:, arguments:, options:, block:)
+        subject
+      end
+
+      protected
+
+      def setup_body
+        test_class.class_eval(&@body) if @body
+      end
+    end
+  end
+end

data/lib/calificador/spec/type_context.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+using Calificador::Util::CoreExtensions
+
+module Calificador
+  module Spec
+    class ExamineContext < BasicContext
+      class Dsl < BasicContext::Dsl
+      end
+
+      def initialize(parent:, subject_key:, description:, overrides: {})
+        super(
+          parent: parent,
+          description: description,
+          subject_key: subject_key,
+          overrides: overrides,
+        )
+      end
+
+      def create_subject(environment:, subject_key:)
+        subject_key.type
+      end
+
+      def subtree_root?
+        true
+      end
+    end
+  end
+end

data/lib/calificador/spec/value_override.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+using Calificador::Util::CoreExtensions
+
+module Calificador
+  module Spec
+    # Factory calss
+    class ValueOverride
+      attr_reader :key, :values
+
+      def initialize(key:, values: {})
+        @key = key
+        @values = values.dup.freeze
+      end
+
+      def merge(other)
+        raise(ArgumentError, "Overrides must have same key") if @key != other.key
+
+        if other.values.empty? || equal?(other)
+          self
+        elsif @values.empty?
+          other
+        else
+          ValueOverride.new(key: @key, values: @values.merge(other.values))
+        end
+      end
+
+      def merge_values(values)
+        if values.empty?
+          self
+        else
+          ValueOverride.new(key: @key, values: @values.merge(values))
+        end
+      end
+    end
+  end
+end

data/lib/calificador/test.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "minitest"
+
+using Calificador::Util::CoreExtensions
+
+module Calificador
+  # Base class for unit tests
+  class Test < ::Minitest::Test
+    include TestMixin
+  end
+end