spec_forge 0.6.0 → 0.7.0

data/lib/spec_forge/normalizer/constraint.rb

@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-
-module SpecForge
-  class Normalizer
-    #
-    # Normalizes constraint hash structure for expectations
-    #
-    # Ensures that expectation constraints (status, json, etc.)
-    # have the correct structure and defaults.
-    #
-    class Constraint < Normalizer
-      #
-      # Defines the normalized structure for configuration validation
-      #
-      # Specifies validation rules for configuration attributes:
-      # - Enforces specific data types
-      # - Provides default values
-      # - Supports alternative key names
-      #
-      # @return [Hash] Configuration attribute validation rules
-      #
-      STRUCTURE = {
-        status: {
-          type: [Integer, String]
-        },
-        json: {
-          type: [Hash, Array],
-          default: {}
-        }
-      }.freeze
-    end
-
-    # On Normalizer
-    class << self
-      #
-      # Generates an empty constraint hash
-      #
-      # @return [Hash] Default constraint hash
-      #
-      def default_constraint
-        Constraint.default
-      end
-
-      #
-      # Normalize a constraint hash
-      #
-      # @param constraint [Hash] Constraint hash
-      #
-      # @return [Array] [normalized_hash, errors]
-      #
-      # @private
-      #
-      def normalize_constraint(constraint)
-        raise Error::InvalidTypeError.new(constraint, Hash, for: "expect") unless Type.hash?(constraint)
-
-        Normalizer::Constraint.new("expect", constraint).normalize
-      end
-    end
-  end
-end

data/lib/spec_forge/normalizer/expectation.rb

@@ -1,105 +0,0 @@
-# frozen_string_literal: true
-
-module SpecForge
-  class Normalizer
-    #
-    # Normalizes expectation hash structure
-    #
-    # Ensures that expectation definitions have the correct structure
-    # and default values for all required settings.
-    #
-    class Expectation < Normalizer
-      #
-      # Defines the normalized structure for configuration validation
-      #
-      # Specifies validation rules for configuration attributes:
-      # - Enforces specific data types
-      # - Provides default values
-      # - Supports alternative key names
-      #
-      # @return [Hash] Configuration attribute validation rules
-      #
-      STRUCTURE = {
-        # Internal
-        id: Normalizer::SHARED_ATTRIBUTES[:id],
-        line_number: Normalizer::SHARED_ATTRIBUTES[:line_number],
-
-        # User defined
-        name: Normalizer::SHARED_ATTRIBUTES[:name],
-        base_url: Normalizer::SHARED_ATTRIBUTES[:base_url],
-        url: Normalizer::SHARED_ATTRIBUTES[:url],
-        http_verb: Normalizer::SHARED_ATTRIBUTES[:http_verb],
-        headers: Normalizer::SHARED_ATTRIBUTES[:headers],
-        query: Normalizer::SHARED_ATTRIBUTES[:query],
-        body: Normalizer::SHARED_ATTRIBUTES[:body],
-        variables: Normalizer::SHARED_ATTRIBUTES[:variables],
-        debug: Normalizer::SHARED_ATTRIBUTES[:debug],
-        store_as: {type: String, default: ""},
-        expect: {type: Hash}
-      }.freeze
-    end
-
-    # On Normalizer
-    class << self
-      #
-      # Generates an empty expectation hash
-      #
-      # @return [Hash] Default expectation hash
-      #
-      def default_expectation
-        Expectation.default
-      end
-
-      #
-      # Normalize an array of expectation hashes
-      #
-      # @param input [Array<Hash>] The array to normalize
-      #
-      # @return [Array<Hash>] Normalized array of expectation hashes
-      #
-      # @raise [Error::InvalidStructureError] If validation fails
-      #
-      def normalize_expectations!(input)
-        raise_errors! do
-          normalize_expectations(input)
-        end
-      end
-
-      #
-      # Normalize an array of expectation hashes
-      #
-      # @param expectations [Array<Hash>] Array of expectation hashes
-      #
-      # @return [Array] [normalized_array, errors]
-      #
-      # @private
-      #
-      def normalize_expectations(expectations)
-        if !Type.array?(expectations)
-          raise Error::InvalidTypeError.new(expectations, Array, for: "\"expectations\" on spec")
-        end
-
-        final_errors = Set.new
-        final_output = expectations.map.with_index do |expectation, index|
-          normalizer = Normalizer::Expectation.new("expectation (item #{index})", expectation)
-          output, errors = normalizer.normalize
-
-          # If expect is not provided, skip the constraints
-          if (constraint = expectation[:expect])
-            constraint_output, constraint_errors = Normalizer::Constraint.new(
-              "expect (item #{index})", constraint
-            ).normalize
-
-            output[:expect] = constraint_output
-            errors.merge(constraint_errors) if constraint_errors.size > 0
-          end
-
-          final_errors.merge(errors) if errors.size > 0
-          output
-        end
-
-        [final_output, final_errors]
-      end
-    end
-  end
-end

data/lib/spec_forge/normalizer/factory.rb

@@ -1,78 +0,0 @@
-# frozen_string_literal: true
-
-module SpecForge
-  class Normalizer
-    #
-    # Normalizes factory hash structure
-    #
-    # Ensures that factory definitions have the correct structure
-    # and default values for all required settings.
-    #
-    class Factory < Normalizer
-      #
-      # Defines the normalized structure for configuration validation
-      #
-      # Specifies validation rules for configuration attributes:
-      # - Enforces specific data types
-      # - Provides default values
-      # - Supports alternative key names
-      #
-      # @return [Hash] Configuration attribute validation rules
-      #
-      STRUCTURE = {
-        model_class: {
-          type: String,
-          aliases: %i[class],
-          default: ""
-        },
-        variables: Normalizer::SHARED_ATTRIBUTES[:variables],
-        attributes: {
-          type: Hash,
-          default: {}
-        }
-      }.freeze
-    end
-
-    # On Normalizer
-    class << self
-      #
-      # Generates an empty factory hash
-      #
-      # @return [Hash] Default factory hash
-      #
-      def default_factory
-        Factory.default
-      end
-
-      #
-      # Normalizes a factory hash with validation
-      #
-      # @param input [Hash] The hash to normalize
-      #
-      # @return [Hash] A normalized hash with defaults applied
-      #
-      # @raise [Error::InvalidStructureError] If validation fails
-      #
-      def normalize_factory!(input)
-        raise_errors! do
-          normalize_factory(input)
-        end
-      end
-
-      #
-      # Normalize a factory hash
-      #
-      # @param factory [Hash] Factory hash
-      #
-      # @return [Array] [normalized_hash, errors]
-      #
-      # @private
-      #
-      def normalize_factory(factory)
-        raise Error::InvalidTypeError.new(factory, Hash, for: "factory") unless Type.hash?(factory)
-
-        Normalizer::Factory.new("factory", factory).normalize
-      end
-    end
-  end
-end

data/lib/spec_forge/normalizer/factory_reference.rb

@@ -1,85 +0,0 @@
-# frozen_string_literal: true
-
-module SpecForge
-  class Normalizer
-    #
-    # Normalizes factory reference hash structure
-    #
-    # Ensures that factory references have the correct structure
-    # and default values for all required settings.
-    #
-    class FactoryReference < Normalizer
-      #
-      # Defines the normalized structure for configuration validation
-      #
-      # Specifies validation rules for configuration attributes:
-      # - Enforces specific data types
-      # - Provides default values
-      # - Supports alternative key names
-      #
-      # @return [Hash] Configuration attribute validation rules
-      #
-      STRUCTURE = {
-        attributes: {
-          type: Hash,
-          default: {}
-        },
-        build_strategy: {
-          type: String,
-          aliases: %i[strategy],
-          default: "create"
-        },
-        size: {
-          type: Integer,
-          aliases: %i[count],
-          default: 0
-        }
-      }.freeze
-    end
-
-    # On Normalizer
-    class << self
-      #
-      # Generates an empty factory reference hash
-      #
-      # @return [Hash] Default factory reference hash
-      #
-      def default_factory_reference
-        FactoryReference.default
-      end
-
-      #
-      # Normalizes a factory reference hash with validation
-      #
-      # @param input [Hash] The hash to normalize
-      #
-      # @return [Hash] A normalized hash with defaults applied
-      #
-      # @raise [Error::InvalidStructureError] If validation fails
-      #
-      def normalize_factory_reference!(input, **)
-        raise_errors! do
-          normalize_factory_reference(input, **)
-        end
-      end
-
-      #
-      # Normalize a factory reference hash
-      #
-      # @param factory [Hash] Factory reference hash
-      # @param label [String] Label for error messages
-      #
-      # @return [Array] [normalized_hash, errors]
-      #
-      # @private
-      #
-      def normalize_factory_reference(factory, label: "factory reference")
-        if !Type.hash?(factory)
-          raise Error::InvalidTypeError.new(factory, Hash, for: "factory reference")
-        end
-
-        Normalizer::FactoryReference.new(label, factory).normalize
-      end
-    end
-  end
-end

data/lib/spec_forge/normalizer/global_context.rb

@@ -1,88 +0,0 @@
-# frozen_string_literal: true
-
-module SpecForge
-  class Normalizer
-    #
-    # Normalizes global context hash structure
-    #
-    # Ensures that global context definitions have the correct structure
-    # and default values for all required settings.
-    #
-    class GlobalContext < Normalizer
-      #
-      # Defines the normalized structure for configuration validation
-      #
-      # Specifies validation rules for configuration attributes:
-      # - Enforces specific data types
-      # - Provides default values
-      # - Supports alternative key names
-      #
-      # @return [Hash] Configuration attribute validation rules
-      #
-      STRUCTURE = {
-        variables: Normalizer::SHARED_ATTRIBUTES[:variables],
-        callbacks: {
-          type: Array,
-          default: [],
-          structure: {
-            type: Hash,
-            default: {},
-            structure: {
-              before_file: Normalizer::SHARED_ATTRIBUTES[:callback],
-              before_spec: Normalizer::SHARED_ATTRIBUTES[:callback],
-              before_each: Normalizer::SHARED_ATTRIBUTES[:callback].merge(aliases: %i[before]),
-              around_each: Normalizer::SHARED_ATTRIBUTES[:callback].merge(aliases: %i[around]),
-              after_each: Normalizer::SHARED_ATTRIBUTES[:callback].merge(aliases: %i[after]),
-              after_spec: Normalizer::SHARED_ATTRIBUTES[:callback],
-              after_file: Normalizer::SHARED_ATTRIBUTES[:callback]
-            }
-          }
-        }
-      }.freeze
-    end
-
-    # On Normalizer
-    class << self
-      #
-      # Generates an empty global context hash
-      #
-      # @return [Hash] Default global context hash
-      #
-      def default_global_context
-        GlobalContext.default
-      end
-
-      #
-      # Normalizes a global context hash with validation
-      #
-      # @param input [Hash] The hash to normalize
-      #
-      # @return [Hash] A normalized hash with defaults applied
-      #
-      # @raise [Error::InvalidStructureError] If validation fails
-      #
-      def normalize_global_context!(input)
-        raise_errors! do
-          normalize_global_context(input)
-        end
-      end
-
-      #
-      # Normalize a global context hash
-      #
-      # @param global [Hash] Global context hash
-      #
-      # @return [Array] [normalized_hash, errors]
-      #
-      # @private
-      #
-      def normalize_global_context(global)
-        if !Type.hash?(global)
-          raise Error::InvalidTypeError.new(global, Hash, for: "global context")
-        end
-
-        Normalizer::GlobalContext.new("global context", global).normalize
-      end
-    end
-  end
-end

data/lib/spec_forge/normalizer/spec.rb

@@ -1,97 +0,0 @@
-# frozen_string_literal: true
-
-module SpecForge
-  class Normalizer
-    #
-    # Normalizes spec hash structure
-    #
-    # Ensures that spec definitions have the correct structure
-    # and default values for all required settings.
-    #
-    class Spec < Normalizer
-      #
-      # Defines the normalized structure for configuration validation
-      #
-      # Specifies validation rules for configuration attributes:
-      # - Enforces specific data types
-      # - Provides default values
-      # - Supports alternative key names
-      #
-      # @return [Hash] Configuration attribute validation rules
-      #
-      STRUCTURE = {
-        # Internal
-        id: Normalizer::SHARED_ATTRIBUTES[:id],
-        name: Normalizer::SHARED_ATTRIBUTES[:name],
-        file_name: {type: String},
-        file_path: {type: String},
-        line_number: Normalizer::SHARED_ATTRIBUTES[:line_number],
-
-        # User defined
-        base_url: Normalizer::SHARED_ATTRIBUTES[:base_url],
-        url: Normalizer::SHARED_ATTRIBUTES[:url],
-        http_verb: Normalizer::SHARED_ATTRIBUTES[:http_verb],
-        headers: Normalizer::SHARED_ATTRIBUTES[:headers],
-        query: Normalizer::SHARED_ATTRIBUTES[:query],
-        body: Normalizer::SHARED_ATTRIBUTES[:body],
-        variables: Normalizer::SHARED_ATTRIBUTES[:variables],
-        debug: Normalizer::SHARED_ATTRIBUTES[:debug],
-        expectations: {type: Array}
-      }.freeze
-    end
-
-    # On Normalizer
-    class << self
-      #
-      # Generates an empty spec hash
-      #
-      # @return [Hash] Default spec hash
-      #
-      def default_spec
-        Spec.default
-      end
-
-      #
-      # Normalizes a spec hash with validation and processes expectations
-      #
-      # @param input [Hash] The hash to normalize
-      # @param label [String] Label for error messages
-      #
-      # @return [Hash] A normalized hash with defaults applied
-      #
-      # @raise [Error::InvalidStructureError] If validation fails
-      #
-      def normalize_spec!(input, label: "spec")
-        raise_errors! do
-          output, errors = normalize_spec(input, label:)
-
-          # Process expectations
-          if (expectations = input[:expectations]) && Type.array?(expectations)
-            expectation_output, expectation_errors = normalize_expectations(expectations)
-
-            output[:expectations] = expectation_output
-            errors += expectation_errors if expectation_errors.size > 0
-          end
-
-          [output, errors]
-        end
-      end
-
-      #
-      # Normalize a spec hash
-      #
-      # @param spec [Hash] Spec hash
-      # @param label [String] Label for error messages
-      #
-      # @return [Array] [normalized_hash, errors]
-      #
-      # @private
-      #
-      def normalize_spec(spec, label: "spec")
-        raise Error::InvalidTypeError.new(spec, Hash, for: label) unless Type.hash?(spec)
-
-        Normalizer::Spec.new(label, spec).normalize
-      end
-    end
-  end
-end