spec_forge 0.1.0 → 0.2.0

data/lib/spec_forge/attribute/chainable.rb

@@ -5,7 +5,7 @@ module SpecForge
     module Chainable
       NUMBER_REGEX = /^\d+$/i
 
-      attr_reader :invocation_chain, :base_object
+      attr_reader :header, :invocation_chain, :base_object
 
       #
       # Represents any attribute that is a series of chained invocations:
@@ -21,37 +21,40 @@ module SpecForge
         # Drop the keyword
         sections = input.split(".")[1..]
 
-        # The "header" is the first element in this array
-        @invocation_chain = sections || []
+        @header = sections.first&.to_sym
+        @invocation_chain = sections[1..] || []
       end
 
       def value
         invoke_chain
       end
 
-      #
-      # Custom implementation to ensure the underlying values are resolved
-      # without breaking #value's functionality
-      #
       def resolve
-        @resolved ||= __resolve(invoke_chain(resolve: true))
+        @resolved ||= resolve_chain
       end
 
       private
 
-      def invoke_chain(resolve: false)
-        current_value = @base_object
+      def invoke_chain
+        traverse_chain(resolve: false)
+      end
+
+      def resolve_chain
+        __resolve(traverse_chain(resolve: true))
+      end
+
+      def traverse_chain(resolve:)
+        result = invocation_chain.reduce(base_object) do |current_value, step|
+          next_value = retrieve_value(current_value, resolve:)
 
-        invocation_chain.each do |step|
-          object = retrieve_value(current_value, resolve:)
-          current_value = invoke(step, object)
+          invoke(step, next_value)
         end
 
-        retrieve_value(current_value, resolve:)
+        retrieve_value(result, resolve:)
       end
 
-      def retrieve_value(object, resolve: false)
-        return object if !object.is_a?(Attribute)
+      def retrieve_value(object, resolve:)
+        return object unless object.is_a?(Attribute)
 
         resolve ? object.resolve : object.value
       end

data/lib/spec_forge/attribute/factory.rb

@@ -14,7 +14,7 @@ module SpecForge
         build_stubbed
       ].freeze
 
-      attr_reader :factory_name
+      alias_method :factory_name, :header
 
       #
       # Represents any attribute that is a factory reference
@@ -24,39 +24,27 @@ module SpecForge
       def initialize(...)
         super
 
-        @factory_name = invocation_chain.shift&.to_sym
-
         # Check the arguments before preparing them
         arguments[:keyword] = Normalizer.normalize_factory_reference!(arguments[:keyword])
 
         prepare_arguments!
       end
 
-      def value
-        @base_object = create_factory_object
-        super
-      end
-
-      def resolve
-        @base_object = create_factory_object
-        super
-      end
-
       private
 
-      def create_factory_object
+      def base_object
         attributes = arguments[:keyword]
-        return FactoryBot.create(@factory_name) if attributes.blank?
+        return FactoryBot.create(factory_name) if attributes.blank?
 
         # Determine build strat
-        build_strategy = attributes[:build_strategy].resolve
+        build_strategy = attributes[:build_strategy].resolve_value
 
         # stubbed => build_stubbed
         build_strategy.prepend("build_") if build_strategy == "stubbed"
         raise InvalidBuildStrategy, build_strategy unless BUILD_STRATEGIES.include?(build_strategy)
 
-        attributes = attributes[:attributes].resolve
-        FactoryBot.public_send(build_strategy, @factory_name, **attributes)
+        attributes = attributes[:attributes].resolve_value
+        FactoryBot.public_send(build_strategy, factory_name, **attributes)
       end
     end
   end

data/lib/spec_forge/attribute/faker.rb

@@ -3,6 +3,8 @@
 module SpecForge
   class Attribute
     class Faker < Parameterized
+      include Chainable
+
       KEYWORD_REGEX = /^faker\./i
 
       attr_reader :faker_class, :faker_method
@@ -15,39 +17,73 @@ module SpecForge
       def initialize(...)
         super
 
-        # As of right now, Faker only goes 2 sub classes deep. I've added +2 padding just in case
-        # faker.class.method
-        # faker.class.subclass.method
-        sections = input.split(".")[0..5]
+        @faker_class, @faker_method = extract_faker_call
+
+        prepare_arguments!
+      end
+
+      private
+
+      def base_object
+        if uses_positional_arguments?(faker_method)
+          faker_method.call(*arguments[:positional].resolve)
+        elsif uses_keyword_arguments?(faker_method)
+          faker_method.call(**arguments[:keyword].resolve)
+        else
+          faker_method.call
+        end
+      end
+
+      def extract_faker_call
+        class_name = header.downcase.to_s
+
+        # Simple case: faker.<header>.<method>
+        if invocation_chain.size == 1
+          return resolve_faker_class_and_method(class_name, invocation_chain.shift)
+        end
+
+        # Try each part of the chain as a potential class name
+        # Example: faker.games.zelda.game.underscore
+        namespace = []
+
+        while invocation_chain.any?
+          part = invocation_chain.first.downcase
+          test_class_name = ([class_name] + namespace + [part]).map(&:camelize).join("::")
+
+          begin
+            "::Faker::#{test_class_name}".constantize
 
-        class_name = sections[0..-2].join("::").underscore.classify
-        method_name = sections.last
+            namespace << invocation_chain.shift
+          rescue NameError
+            # This part isn't a valid class, so it must be our method
+            method_name = invocation_chain.shift
+            class_name = ([class_name] + namespace).map(&:camelize).join("::")
+
+            return resolve_faker_class_and_method(class_name, method_name)
+          end
+        end
 
+        # If we get here, we consumed all parts as classes but found no method
+        class_name = ([class_name] + namespace).map(&:camelize).join("::")
+        raise InvalidFakerMethodError.new(nil, "::#{class_name}".constantize)
+      end
+
+      def resolve_faker_class_and_method(class_name, method_name)
         # Load the class
-        @faker_class = begin
-          "::#{class_name}".constantize
+        faker_class = begin
+          "::Faker::#{class_name.camelize}".constantize
         rescue NameError
           raise InvalidFakerClassError, class_name
         end
 
         # Load the method
-        @faker_method = begin
+        faker_method = begin
           faker_class.method(method_name)
         rescue NameError
           raise InvalidFakerMethodError.new(method_name, faker_class)
         end
 
-        prepare_arguments!
-      end
-
-      def value
-        if uses_positional_arguments?(faker_method)
-          faker_method.call(*arguments[:positional].resolve)
-        elsif uses_keyword_arguments?(faker_method)
-          faker_method.call(**arguments[:keyword].resolve)
-        else
-          faker_method.call
-        end
+        [faker_class, faker_method]
       end
     end
   end

data/lib/spec_forge/attribute/literal.rb

@@ -22,6 +22,10 @@ module SpecForge
             input
           end
       end
+
+      def resolve
+        @value
+      end
     end
   end
 end

data/lib/spec_forge/attribute/resolvable.rb

@@ -6,16 +6,14 @@ module SpecForge
     # Helpers for ResolvableHash and ResolvableArray
     #
     module Resolvable
-      # @private
-      def to_proc
-        this = self
-        -> { this.resolve }
-      end
-
       # @private
       def resolvable_proc
         ->(v) { v.respond_to?(:resolve) ? v.resolve : v }
       end
+
+      def resolvable_value_proc
+        ->(v) { v.respond_to?(:resolve_value) ? v.resolve_value : v }
+      end
     end
   end
 end

data/lib/spec_forge/attribute/resolvable_array.rb

@@ -16,6 +16,10 @@ module SpecForge
         value.map(&resolvable_proc)
       end
 
+      def resolve_value
+        value.map(&resolvable_value_proc)
+      end
+
       def bind_variables(variables)
         value.each { |v| Attribute.bind_variables(v, variables) }
       end

data/lib/spec_forge/attribute/resolvable_hash.rb

@@ -16,6 +16,10 @@ module SpecForge
         value.transform_values(&resolvable_proc)
       end
 
+      def resolve_value
+        value.transform_values(&resolvable_value_proc)
+      end
+
       def bind_variables(variables)
         value.each_value { |v| Attribute.bind_variables(v, variables) }
       end

data/lib/spec_forge/attribute/variable.rb

@@ -2,24 +2,17 @@
 
 module SpecForge
   class Attribute
+    #
+    # Represents any attribute that is a variable reference
+    #
+    #   variables.<variable_name>
+    #
     class Variable < Attribute
       include Chainable
 
       KEYWORD_REGEX = /^variables\./i
 
-      attr_reader :variable_name
-
-      #
-      # Represents any attribute that is a variable reference
-      #
-      #   variables.<variable_name>
-      #
-      def initialize(...)
-        super
-
-        # Remove the variable name from the chain
-        @variable_name = invocation_chain.shift&.to_sym
-      end
+      alias_method :variable_name, :header
 
       def bind_variables(variables)
         raise InvalidTypeError.new(variables, Hash, for: "'variables'") unless Type.hash?(variables)

data/lib/spec_forge/attribute.rb

@@ -138,8 +138,6 @@ module SpecForge
 
     #
     # Returns the fully evaluated result, recursively resolving any nested attributes
-    # Note: This method can only be called once to ensure data is correct across the board
-    # You can still call #value if you need a new value
     #
     # @return [Object] The resolved value
     #
@@ -152,18 +150,11 @@ module SpecForge
     #   attr.resolve # => [42, ["Jane"]]
     #
     def resolve
-      # Past test for the variable
-      @resolved ||= __resolve(value)
+      @resolved ||= resolve_value
     end
 
-    #
-    # Wraps the call to #resolve in a proc. Used with FactoryBot
-    #
-    # @return [Proc]
-    #
-    def to_proc
-      this = self # kek - what are we, javascript?
-      -> { this.resolve }
+    def resolve_value
+      __resolve(value)
     end
 
     #

data/lib/spec_forge/cli/init.rb

@@ -13,17 +13,10 @@ module SpecForge
         actions.empty_directory "#{base_path}/specs"
 
         actions.template(
-          "config.tt",
-          SpecForge.root.join(base_path, "config.yml"),
-          context: binding
+          "forge_helper.tt",
+          SpecForge.root.join(base_path, "forge_helper.rb")
         )
       end
-
-      def default_authorization_value
-        <<~STRING.chomp
-          Bearer <%= ENV.fetch("API_TOKEN", "") %>
-        STRING
-      end
     end
   end
 end

data/lib/spec_forge/configuration.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module SpecForge
+  class Configuration < Struct.new(:base_url, :headers, :query, :factories, :specs, :on_debug)
+    ############################################################################
+
+    class Factories < Struct.new(:auto_discover, :paths)
+      attr_predicate :auto_discover, :paths
+
+      def initialize(auto_discover: true, paths: []) = super
+    end
+
+    ############################################################################
+
+    def self.overlay_options(source, overlay)
+      source.deep_merge(overlay) do |key, source_value, overlay_value|
+        # If overlay has a populated value, use it
+        if overlay_value.present? || overlay_value == false
+          overlay_value
+        # If source is nil and overlay exists (but wasn't "present"), use overlay
+        elsif source_value.nil? && !overlay_value.nil?
+          overlay_value
+        # Otherwise keep source value
+        else
+          source_value
+        end
+      end
+    end
+
+    def initialize
+      config = Normalizer.default_configuration
+
+      config[:base_url] = "http://localhost:3000"
+      config[:factories] = Factories.new
+      config[:specs] = RSpec.configuration
+      config[:on_debug] = Runner::DebugProxy.default
+
+      super(**config)
+    end
+
+    def validate
+      output = Normalizer.normalize_configuration!(to_h)
+
+      # In case any value was set to `nil`
+      self.base_url = output[:base_url] if base_url.blank?
+      self.query = output[:query] if query.blank?
+      self.headers = output[:headers] if headers.blank?
+
+      self
+    end
+
+    def to_h
+      hash = super.except(:specs)
+      hash[:factories] = hash[:factories].to_h
+      hash
+    end
+  end
+end

data/lib/spec_forge/factory.rb

@@ -8,11 +8,11 @@ module SpecForge
     # @param path [String, Path] The base path where the factories directory are located
     #
     def self.load_and_register(base_path)
-      if (paths = SpecForge.config.factories.paths) && paths.size > 0
-        FactoryBot.definition_file_paths = paths
+      if SpecForge.configuration.factories.paths?
+        FactoryBot.definition_file_paths = SpecForge.configuration.factories.paths
       end
 
-      FactoryBot.find_definitions if SpecForge.config.factories.auto_discover?
+      FactoryBot.find_definitions if SpecForge.configuration.factories.auto_discover?
 
       factories = load_from_path(base_path.join("factories", "**/*.yml"))
       factories.each(&:register)
@@ -80,7 +80,7 @@ module SpecForge
       factory_forge = self
       dsl.factory(name, options) do
         factory_forge.attributes.each do |name, attribute|
-          add_attribute(name, &attribute.to_proc)
+          add_attribute(name) { attribute.resolve_value }
         end
       end
 

data/lib/spec_forge/http/backend.rb

@@ -3,6 +3,9 @@
 module SpecForge
   module HTTP
     class Backend
+      CURLY_PLACEHOLDER = /\{(\w+)\}/
+      COLON_PLACEHOLDER = /:(\w+)/
+
       attr_reader :connection
 
       #
@@ -13,20 +16,14 @@ module SpecForge
       def initialize(request)
         @connection =
           Faraday.new(url: request.base_url) do |builder|
-            # Authorization
-            builder.headers[request.authorization.header] = request.authorization.value
-
             # Content-Type
             if !request.headers.key?("Content-Type")
               builder.request :json
               builder.response :json
             end
 
-            # Headers / Content Type
-            builder.headers.merge!(request.headers)
-
-            # Params
-            builder.params.merge!(request.query.resolve)
+            # Headers
+            builder.headers.merge!(request.headers.resolve)
           end
       end
 
@@ -40,6 +37,7 @@ module SpecForge
       # @return [Hash] The response
       #
       def delete(url, query: {}, body: {})
+        url = normalize_url(url, query)
         connection.delete(url) { |request| update_request(request, query, body) }
       end
 
@@ -53,6 +51,7 @@ module SpecForge
       # @return [Hash] The response
       #
       def get(url, query: {}, body: {})
+        url = normalize_url(url, query)
         connection.get(url) { |request| update_request(request, query, body) }
       end
 
@@ -66,6 +65,7 @@ module SpecForge
       # @return [Hash] The response
       #
       def patch(url, query: {}, body: {})
+        url = normalize_url(url, query)
         connection.patch(url) { |request| update_request(request, query, body) }
       end
 
@@ -79,6 +79,7 @@ module SpecForge
       # @return [Hash] The response
       #
       def post(url, query: {}, body: {})
+        url = normalize_url(url, query)
         connection.post(url) { |request| update_request(request, query, body) }
       end
 
@@ -92,6 +93,7 @@ module SpecForge
       # @return [Hash] The response
       #
       def put(url, query: {}, body: {})
+        url = normalize_url(url, query)
         connection.put(url) { |request| update_request(request, query, body) }
       end
 
@@ -101,6 +103,38 @@ module SpecForge
         request.params.merge!(query)
         request.body = body.to_json
       end
+
+      def normalize_url(url, query)
+        # /users/<user_id>
+        url = replace_url_placeholder(url, query, CURLY_PLACEHOLDER)
+
+        # /users/:user_id
+        url = replace_url_placeholder(url, query, COLON_PLACEHOLDER)
+
+        # Attempt to validate (the colon style is considered valid apparently)
+        begin
+          URI.parse(url)
+        rescue URI::InvalidURIError
+          raise URI::InvalidURIError,
+            "#{url.inspect} is not a valid URI. If you're using path parameters (like ':id' or '{id}'), ensure they are defined in the 'query' section."
+        end
+
+        url
+      end
+
+      def replace_url_placeholder(url, query, regex)
+        match = url.match(regex)
+        return url if match.nil?
+
+        key = match[1].to_sym
+        return url unless query.key?(key)
+
+        value = query.delete(key)
+        url.gsub(
+          match[0],
+          URI.encode_uri_component(value.to_s)
+        )
+      end
     end
   end
 end

data/lib/spec_forge/http/client.rb

@@ -24,8 +24,8 @@ module SpecForge
         @adapter.public_send(
           request.http_verb,
           request.url,
-          query: request.query.transform_values(&:resolve),
-          body: request.body.transform_values(&:resolve)
+          query: request.query.resolve,
+          body: request.body.resolve
         )
       end
     end

data/lib/spec_forge/http/request.rb

@@ -2,9 +2,7 @@
 
 module SpecForge
   module HTTP
-    attributes = [:base_url, :url, :http_method, :headers, :query, :body, :authorization]
-
-    class Request < Data.define(*attributes)
+    class Request < Data.define(:base_url, :url, :http_method, :headers, :query, :body)
       HEADER = /^[A-Z][A-Za-z0-9!-]*$/
 
       #
@@ -23,33 +21,36 @@ module SpecForge
       # @option options [Hash] :body The request body (defaults to {})
       #
       def initialize(**options)
-        base_url = extract_base_url(options)
         url = extract_url(options)
-        headers = normalize_headers(options)
+        base_url = extract_base_url(options)
         http_method = normalize_http_method(options)
+        headers = normalize_headers(options)
         query = normalize_query(options)
         body = normalize_body(options)
-        authorization = extract_authorization(options)
 
-        super(base_url:, url:, http_method:, headers:, query:, body:, authorization:)
+        super(base_url:, url:, http_method:, headers:, query:, body:)
       end
 
       def http_verb
         http_method.name.downcase
       end
 
+      def to_h
+        super.transform_values { |v| v.respond_to?(:resolve) ? v.resolve : v }
+      end
+
       private
 
       def extract_base_url(options)
-        options[:base_url]&.value&.presence || SpecForge.config.base_url
+        options[:base_url].resolve
       end
 
       def extract_url(options)
-        options[:url].value
+        options[:url].resolve
       end
 
       def normalize_http_method(options)
-        method = options[:http_method].value.presence || "GET"
+        method = options[:http_method].resolve.presence || "GET"
 
         if method.is_a?(String)
           Verb.from(method)
@@ -84,10 +85,6 @@ module SpecForge
         body = Attribute.bind_variables(options[:body], options[:variables])
         Attribute::ResolvableHash.new(body)
       end
-
-      def extract_authorization(options)
-        SpecForge.config.authorization.default
-      end
     end
   end
 end