calificador 0.1.0 → 0.2.0

data/lib/calificador/build/basic_factory.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+module Calificador
+  module Build
+    # Factory calss
+    class BasicFactory
+      # Configuration derived factories
+      class Dsl < Util::ProxyObject
+        attr_reader :__factory
+
+        def initialize(factory:)
+          super()
+
+          @__factory = factory
+        end
+
+        def add_attribute(name, **properties, &config)
+          type ||= __default_property_type(name: name)
+          attribute = Attribute.new(name: name, type: type, config: config)
+          @__factory.add_attribute(attribute)
+        end
+
+        def init_with(&block)
+          raise "Initializer requires a block to create the object" if block.nil?
+
+          @__factory.init_with = block
+        end
+
+        def before_create(&block)
+          raise "Before requires a block to call" if block.nil?
+
+          @__factory.before_create = block
+        end
+
+        def after_create(&block)
+          raise "After requires a block to call" if block.nil?
+
+          @__factory.after_create = block
+        end
+
+        def trait(trait, description = nil, &block)
+          factory = __create_factory(trait: trait, description: description, source_location: block.source_location)
+          factory.dsl.instance_exec(&block)
+          @__factory.context.add_factory(factory)
+        end
+
+        def singleton_method_added(name) # rubocop:disable Lint/MissingSuper
+          ::Kernel.raise "Adding methods (#{name}) inside factory definitions is not supported"
+        end
+
+        protected
+
+        def __respond_to_missing?(name:, include_all:)
+          name.start_with?("__") ? super : true
+        end
+
+        def __method_missing(name:, arguments:, keywords:, block:)
+          if name.start_with?("__")
+            super
+          else
+            unless arguments.empty?
+              ::Kernel.raise ::ArgumentError, <<~ERROR
+                Attribute '#{name}' cannot have arguments. Please use a block to configure the value
+              ERROR
+            end
+
+            ::Kernel.raise ::ArgumentError, "Attribute '#{name}' must have a block to provide the value" if block.nil?
+
+            add_attribute(name, &block)
+          end
+        end
+
+        def __default_trait_description(trait:)
+          trait.to_s.gsub("_", " ").chomp
+        end
+
+        def __create_factory(trait:, description:, source_location:)
+          raise NotImplementedError, "Subclasses must implement"
+        end
+
+        def __default_property_type(name:)
+          raise NotImplementedError, "Subclasses must implement"
+        end
+      end
+
+      attr_reader :parent, :description, :key, :context, :name, :source_location
+      attr_accessor :init_with, :before_create, :after_create
+
+      def initialize(context:, parent: nil, key:, name:, description: nil, source_location:)
+        raise "Parent factory must have same type" unless parent.nil? || parent.key.type == key.type
+
+        @context = context
+        @key = key
+        @name = name.to_sym
+        @source_location = source_location
+        @parent = parent
+        @description = description.dup.freeze
+        @attributes = {}
+        @init_with = nil
+        @before_create = nil
+        @after_create = nil
+      end
+
+      def create(environment:)
+        evaluator = AttributeEvaluator.new(key: @key, environment: environment)
+
+        collect_attributes(evaluator: evaluator)
+
+        exec_before_create(evaluator: evaluator)
+
+        object = create_object(evaluator: evaluator)
+
+        set_properties(object: object, evaluator: evaluator)
+
+        exec_after_create(evaluator: evaluator, object: object)
+
+        object
+      end
+
+      def attributes
+        @attributes.dup.freeze
+      end
+
+      def attribute(name:)
+        @attributes[name]
+      end
+
+      def add_attribute(attribute)
+        raise KeyError, "Duplicate attribute name #{attribute.name}" if @attributes.key?(attribute.name)
+
+        @attributes[attribute.name] = attribute
+      end
+
+      def add_overrides(overrides)
+        overrides.each do |name, value|
+          current_attribute = @parent&.lookup_attribute(name: name)
+
+          attribute = Attribute.new(name: name, type: current_attribute&.type || :property, config: value)
+          add_attribute(attribute)
+        end
+      end
+
+      def lookup_attribute(name:)
+        @attributes.fetch(name) do
+          @parent&.lookup_attribute(name: name)
+        end
+      end
+
+      def dsl
+        self.class.const_get(:Dsl).new(factory: self)
+      end
+
+      protected
+
+      def collect_attributes(evaluator:)
+        @parent&.collect_attributes(evaluator: evaluator)
+        evaluator.add_attributes(@attributes.values)
+      end
+
+      def exec_before_create(evaluator:)
+        @parent&.exec_before_create(evaluator: evaluator)
+        evaluator.evaluate(&@before_create) unless @before_create.nil?
+      end
+
+      def exec_after_create(evaluator:, object:)
+        @parent&.exec_after_create(evaluator: evaluator, object: object)
+        evaluator.evaluate(object, &@after_create) unless @after_create.nil?
+      end
+
+      def nearest_init_with
+        @init_with || @parent&.nearest_init_with
+      end
+
+      def create_object(evaluator:)
+        init_with = nearest_init_with
+
+        if init_with.nil?
+          instantiate_object(evaluator: evaluator)
+        else
+          evaluator.evaluate(&init_with)
+        end
+      end
+
+      def set_properties(object:, evaluator:)
+        evaluator.attributes.each_value do |attribute|
+          object.send(:"#{attribute.name}=", evaluator.value(name: attribute.name)) if attribute.type == :property
+        end
+      end
+
+      def instantiate_object(evaluator:)
+        raise "Cannot instantiate #{@key} without init function"
+      end
+    end
+  end
+end

data/lib/calificador/build/mock_factory.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+module Calificador
+  module Build
+    # Factory for mock objects
+    class MockFactory < BasicFactory
+      # Configuration derived factories
+      class Dsl < BasicFactory::Dsl
+        def expect(&block)
+          __factory.expect = block
+        end
+
+        protected
+
+        def __create_factory(trait:, description:, source_location:)
+          MockFactory.new(
+            context: __factory.context,
+            parent: __factory,
+            key: __factory.key.with(trait),
+            name: [__factory.name, trait].compact.join("_"),
+            source_location: source_location,
+            description: description || __default_trait_description(trait: trait)
+          )
+        end
+
+        def __default_property_type(name:)
+          :transient
+        end
+      end
+
+      class ExpectProxy < Util::ProxyObject
+        def initialize(mock:, evaluator:)
+          super()
+
+          @mock = mock
+          @evaluator = evaluator
+          @environment = @evaluator.environment
+          @test_instance = @environment.test_instance
+        end
+
+        def mock
+          MockProxy.new(mock: @mock)
+        end
+
+        protected
+
+        def __respond_to_missing?(name:, include_all:)
+          @evaluator.attribute?(name: name) ||
+            !@environment.lookup_named_factory(name: name).nil? ||
+            @test_instance.respond_to?(name, false)
+        end
+
+        def __method_missing(name:, arguments:, keywords:, block:)
+          if @evaluator.attribute?(name: name)
+            @evaluator.value(name: name)
+          else
+            factory = @environment.lookup_named_factory(name: name)
+
+            if factory
+              @environment.create_object(key: factory.key)
+            else
+              @test_instance.send(name, *arguments, **keywords, &block)
+            end
+          end
+        end
+      end
+
+      class MockProxy < Util::ProxyObject
+        def initialize(mock:)
+          super()
+
+          @mock = mock
+        end
+
+        protected
+
+        def __respond_to_missing?(name:, include_all:)
+          METHOD_PATTERN =~ name || super
+        end
+
+        def __method_missing(name:, arguments:, keywords:, block:)
+          if METHOD_PATTERN =~ name
+            MockCall.new(mock: @mock, name: name, arguments: arguments, keywords: keywords, block: block)
+          else
+            super
+          end
+        end
+      end
+
+      class MockCall
+        attr_reader :name, :arguments, :keywords, :block
+
+        def initialize(mock:, name:, arguments:, keywords:, block:)
+          @mock = mock
+          @name = name
+          @arguments = arguments
+          @keywords = keywords
+          @block = block
+        end
+
+        def >>(other)
+          @mock.expect(@name, other, combined_arguments)
+        end
+
+        protected
+
+        def combined_arguments
+          arguments = @arguments
+          arguments += [@keywords] unless keywords.empty?
+          arguments
+        end
+      end
+
+      attr_accessor :expect
+
+      def initialize(context:, parent: nil, key:, name:, description: nil, source_location:)
+        unless parent.nil?
+          raise "Parent factory must be a #{MockFactory}" unless parent.is_a?(MockFactory)
+          raise "Parent factory must have same type" unless parent.key.type == key.type
+        end
+
+        super(
+          context: context,
+          parent: parent,
+          key: key,
+          name: name,
+          description: description,
+          source_location: source_location
+        )
+
+        @expect = nil
+      end
+
+      def add_attribute(attribute)
+        raise ArgumentError, "Attribute must be transient" unless attribute.type == :transient
+
+        super
+      end
+
+      def set_properties(object:, evaluator:)
+        ExpectProxy.new(mock: object, evaluator: evaluator).instance_exec(&@expect) if @expect
+      end
+
+      protected
+
+      def instantiate_object(evaluator:)
+        ::Minitest::Mock.new
+      end
+    end
+  end
+end

data/lib/calificador/build/object_factory.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Calificador
+  module Build
+    # Factory for objects
+    class ObjectFactory < BasicFactory
+      # Configuration derived factories
+      class Dsl < BasicFactory::Dsl
+        def initialize(factory:)
+          super(factory: factory)
+
+          @property_type = nil
+        end
+
+        def transient(&block)
+          raise ArgumentError, "Transient requires a block" if block.nil?
+
+          old_property_type = @property_type
+          @property_type = :transient
+
+          begin
+            instance_exec(&block)
+          ensure
+            @property_type = old_property_type
+          end
+        end
+
+        protected
+
+        def __create_factory(trait:, description:, source_location:)
+          ObjectFactory.new(
+            context: __factory.context,
+            parent: __factory,
+            key: __factory.key.with(trait),
+            name: [__factory.name, trait].compact.join("_"),
+            source_location: source_location,
+            description: description || __default_trait_description(trait: trait)
+          )
+        end
+
+        def __default_property_type(name:)
+          __factory.parent&.attribute(name: name)&.type || @property_type || :property
+        end
+      end
+
+      def initialize(context:, parent: nil, key:, name:, description: nil, source_location:)
+        unless parent.nil?
+          raise "Parent factory must be a #{ObjectFactory}" unless parent.is_a?(ObjectFactory)
+          raise "Parent factory must have same type" unless parent.key.type == key.type
+        end
+
+        super(
+          context: context,
+          parent: parent,
+          key: key,
+          name: name,
+          description: description,
+          source_location: source_location
+        )
+      end
+
+      protected
+
+      def instantiate_object(evaluator:)
+        parameters = []
+        options = {}
+
+        @key.type.instance_method(:initialize).parameters.each do |type, name|
+          case type
+          when :req
+            parameters << evaluator.value(name: name)
+          when :opt
+            parameters << evaluator.value(name: name) if evaluator.attribute?(name: name)
+          when :keyreq
+            options[name] = evaluator.value(name: name)
+          when :key
+            options[name] = evaluator.value(name: name) if evaluator.attribute?(name: name)
+          end
+        end
+
+        @key.type.new(*parameters, **options)
+      end
+    end
+  end
+end

data/lib/calificador/build/trait.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module Calificador
-  module Build
-    # Trait description
-    class Trait < AttributeContainer
-      # Configuration proxy for traits
-      class Dsl < AttributeContainer::Dsl
-      end
-
-      attr_reader :name
-
-      def initialize(parent:, name:, description: nil)
-        super(parent: parent, description: description)
-
-        @name = name.to_sym
-      end
-    end
-  end
-end