spec_forge 0.1.0

data/flake.nix

@@ -0,0 +1,41 @@
+{
+  description = "Ruby 3.3.6 development environment";
+
+  inputs = {
+    nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
+    flake-utils.url = "github:numtide/flake-utils";
+  };
+
+  outputs = { self, nixpkgs, flake-utils }:
+    flake-utils.lib.eachDefaultSystem (system:
+      let
+        pkgs = nixpkgs.legacyPackages.${system};
+      in
+      {
+        devShells.default = pkgs.mkShell {
+          buildInputs = with pkgs; [
+            (ruby_3_3.override {
+              jemallocSupport = true;
+              docSupport = false;
+            })
+
+            # Dependencies for native gems
+            pkg-config
+            openssl
+            readline
+            zstd
+            libyaml
+          ];
+
+          shellHook = ''
+            export GEM_HOME="$PWD/vendor/bundle"
+            export GEM_PATH="$GEM_HOME"
+            export PATH="$GEM_HOME/bin:$PATH"
+
+            echo "checking gems"
+            bundle check || bundle install
+          '';
+        };
+      }
+    );
+}

data/lib/spec_forge/attribute/chainable.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module SpecForge
+  class Attribute
+    module Chainable
+      NUMBER_REGEX = /^\d+$/i
+
+      attr_reader :invocation_chain, :base_object
+
+      #
+      # Represents any attribute that is a series of chained invocations:
+      #
+      #   <keyword>.<header>.<segment(hash_key | method | index)>...
+      #
+      # This module is not used as is, but is included in another class.
+      # Note: There can be any n number of segments.
+      #
+      def initialize(...)
+        super
+
+        # Drop the keyword
+        sections = input.split(".")[1..]
+
+        # The "header" is the first element in this array
+        @invocation_chain = sections || []
+      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))
+      end
+
+      private
+
+      def invoke_chain(resolve: false)
+        current_value = @base_object
+
+        invocation_chain.each do |step|
+          object = retrieve_value(current_value, resolve:)
+          current_value = invoke(step, object)
+        end
+
+        retrieve_value(current_value, resolve:)
+      end
+
+      def retrieve_value(object, resolve: false)
+        return object if !object.is_a?(Attribute)
+
+        resolve ? object.resolve : object.value
+      end
+
+      def invoke(step, object)
+        if hash_key?(object, step)
+          object[step.to_sym]
+        elsif index?(object, step)
+          object[step.to_i]
+        elsif method?(object, step)
+          object.public_send(step)
+        else
+          raise InvalidInvocationError.new(step, object)
+        end
+      end
+
+      def hash_key?(object, key)
+        # This is to support the silly delegator
+        method?(object, :key?) && object.key?(key.to_sym)
+      end
+
+      def method?(object, method_name)
+        object.respond_to?(method_name)
+      end
+
+      def index?(object, step)
+        # This is to support the silly delegator
+        method?(object, :index) && step.match?(NUMBER_REGEX)
+      end
+    end
+  end
+end

data/lib/spec_forge/attribute/factory.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module SpecForge
+  class Attribute
+    class Factory < Parameterized
+      include Chainable
+
+      KEYWORD_REGEX = /^factories\./i
+
+      BUILD_STRATEGIES = %w[
+        build
+        create
+        attributes_for
+        build_stubbed
+      ].freeze
+
+      attr_reader :factory_name
+
+      #
+      # Represents any attribute that is a factory reference
+      #
+      #   factories.<factory_name>
+      #
+      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
+        attributes = arguments[:keyword]
+        return FactoryBot.create(@factory_name) if attributes.blank?
+
+        # Determine build strat
+        build_strategy = attributes[:build_strategy].resolve
+
+        # 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)
+      end
+    end
+  end
+end

data/lib/spec_forge/attribute/faker.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module SpecForge
+  class Attribute
+    class Faker < Parameterized
+      KEYWORD_REGEX = /^faker\./i
+
+      attr_reader :faker_class, :faker_method
+
+      #
+      # Represents any attribute that is a faker call
+      #
+      #   faker.<faker_class>.<faker_method>
+      #
+      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]
+
+        class_name = sections[0..-2].join("::").underscore.classify
+        method_name = sections.last
+
+        # Load the class
+        @faker_class = begin
+          "::#{class_name}".constantize
+        rescue NameError
+          raise InvalidFakerClassError, class_name
+        end
+
+        # Load the method
+        @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
+      end
+    end
+  end
+end

data/lib/spec_forge/attribute/literal.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module SpecForge
+  class Attribute
+    class Literal < Attribute
+      REGEX_REGEX = /^\/.+\/[mnix\s]*$/i
+
+      attr_reader :value
+
+      #
+      # Represents any attribute that is a literal value.
+      # A literal value can be any value YAML value, except Array and Hash
+      #
+      def initialize(input)
+        super
+
+        @value =
+          case input
+          when REGEX_REGEX
+            Regexp.new(input)
+          else
+            input
+          end
+      end
+    end
+  end
+end

data/lib/spec_forge/attribute/matcher.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module SpecForge
+  class Attribute
+    class Matcher < Parameterized
+      class Methods
+        include RSpec::Matchers
+      end
+
+      MATCHER_METHODS = Methods.new.freeze
+      KEYWORD_REGEX = /^matcher\.|^be\.|^kind_of\./i
+
+      LITERAL_MAPPINGS = {
+        "nil" => nil,
+        "true" => true,
+        "false" => false
+      }.freeze
+
+      attr_reader :matcher_method
+
+      #
+      # Represents any attribute that is a matcher call.
+      #
+      #   matcher.<method>
+      #   be.<method>
+      #   kind_of.<method>
+      #
+      def initialize(...)
+        super
+
+        namespace, method = extract_namespace_and_method
+
+        @matcher_method =
+          case namespace
+          when "be"
+            resolve_be_matcher(method)
+          when "kind_of"
+            resolve_kind_of_matcher(method)
+          else
+            resolve_matcher(method)
+          end
+
+        prepare_arguments!
+      end
+
+      def value
+        if uses_positional_arguments?(matcher_method)
+          positional = arguments[:positional].resolve.each do |value|
+            value.deep_stringify_keys! if value.respond_to?(:deep_stringify_keys!)
+          end
+
+          matcher_method.call(*positional)
+        elsif uses_keyword_arguments?(matcher_method)
+          matcher_method.call(**arguments[:keyword].resolve.deep_stringify_keys)
+        else
+          matcher_method.call
+        end
+      end
+
+      private
+
+      def extract_namespace_and_method
+        sections = input.split(".", 2)
+
+        if sections.size > 1
+          sections[..1]
+        else
+          [nil, sections.first]
+        end
+      end
+
+      def resolve_matcher(method_name, namespace: MATCHER_METHODS)
+        namespace.public_method(method_name)
+      end
+
+      def resolve_be_matcher(method)
+        # Resolve any custom matchers
+        resolved_matcher =
+          case method
+
+          # be.>(*args)
+          when "greater_than", "greater"
+            resolve_matcher(:>, namespace: MATCHER_METHODS.be)
+
+          # be.>=(*args)
+          when "greater_than_or_equal", "greater_or_equal"
+            resolve_matcher(:>=, namespace: MATCHER_METHODS.be)
+
+          # be.<(*args)
+          when "less_than", "less"
+            resolve_matcher(:<, namespace: MATCHER_METHODS.be)
+
+          # be.<=(*args)
+          when "less_than_or_equal", "less_or_equal"
+            resolve_matcher(:<=, namespace: MATCHER_METHODS.be)
+
+          # be(nil), be(true), be(false)
+          when "nil", "true", "false"
+            arguments[:positional].insert(0, LITERAL_MAPPINGS[method])
+            resolve_matcher(:be)
+          end
+
+        # Return the matcher if we found one
+        return resolved_matcher if resolved_matcher
+
+        # No matcher found, we're going to assume it's prefixed with "be_"
+        resolve_matcher(:"be_#{method}")
+      end
+
+      def resolve_kind_of_matcher(method)
+        type_class = Object.const_get(method.capitalize)
+        arguments[:positional].insert(0, type_class)
+
+        resolve_matcher(:be_kind_of)
+      end
+    end
+  end
+end

data/lib/spec_forge/attribute/parameterized.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module SpecForge
+  class Attribute
+    class Parameterized < Attribute
+      def self.from_hash(hash)
+        metadata = hash.first
+
+        input = metadata.first
+        arguments = metadata.second
+
+        case arguments
+        when ArrayLike
+          new(input, arguments)
+        when HashLike
+          # Offset for positional arguments. No support for both at this time
+          new(input, [], arguments)
+        else
+          # Single value
+          new(input, [arguments])
+        end
+      end
+
+      attr_reader :arguments
+
+      #
+      # Represents any attribute that is written in expanded form.
+      # Expanded form is just a fancy name for a hash.
+      #
+      #   keyword:
+      #     <attribute>:
+      #       <keyword_arg>: <value>
+      #
+      #   positional:
+      #     <attribute>:
+      #     - <positional_arg>
+      #     - <positional_arg>
+      #
+      # @param input [Hash] The key that contains these arguments
+      # @param positional [Array] Any positional arguments
+      # @param keyword [Hash] Any keyword arguments
+      #
+      def initialize(input, positional = [], keyword = {})
+        super(input.to_s.downcase)
+
+        @arguments = {positional:, keyword:}
+      end
+
+      def bind_variables(variables)
+        arguments[:positional].each { |v| Attribute.bind_variables(v, variables) }
+        arguments[:keyword].each_value { |v| Attribute.bind_variables(v, variables) }
+      end
+
+      protected
+
+      #
+      # Converts the arguments into Attributes
+      #
+      # @note This needs to be called by the inheriting class.
+      #   This is to allow inheriting classes to normalize their arguments before
+      #   they are converted to Attributes
+      #
+      def prepare_arguments!
+        @arguments = Attribute.from(arguments)
+      end
+
+      def uses_positional_arguments?(method)
+        method.parameters.any? { |a| [:req, :opt, :rest].include?(a.first) }
+      end
+
+      def uses_keyword_arguments?(method)
+        method.parameters.any? { |a| [:keyreq, :key, :keyrest].include?(a.first) }
+      end
+    end
+  end
+end

data/lib/spec_forge/attribute/resolvable.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module SpecForge
+  class Attribute
+    #
+    # 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
+    end
+  end
+end

data/lib/spec_forge/attribute/resolvable_array.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module SpecForge
+  class Attribute
+    #
+    # Represents an Array that may contain Attributes
+    #
+    class ResolvableArray < SimpleDelegator
+      include Resolvable
+
+      def value
+        __getobj__
+      end
+
+      def resolve
+        value.map(&resolvable_proc)
+      end
+
+      def bind_variables(variables)
+        value.each { |v| Attribute.bind_variables(v, variables) }
+      end
+    end
+  end
+end

data/lib/spec_forge/attribute/resolvable_hash.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module SpecForge
+  class Attribute
+    #
+    # Represents a hash that may contain Attributes
+    #
+    class ResolvableHash < SimpleDelegator
+      include Resolvable
+
+      def value
+        __getobj__
+      end
+
+      def resolve
+        value.transform_values(&resolvable_proc)
+      end
+
+      def bind_variables(variables)
+        value.each_value { |v| Attribute.bind_variables(v, variables) }
+      end
+    end
+  end
+end

data/lib/spec_forge/attribute/transform.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module SpecForge
+  class Attribute
+    class Transform < Parameterized
+      KEYWORD_REGEX = /^transform\./i
+
+      TRANSFORM_METHODS = %w[
+        join
+      ].freeze
+
+      attr_reader :function
+
+      #
+      # Represents any attribute that is a transform call
+      #
+      #   transform.<function>
+      #
+      def initialize(...)
+        super
+
+        # Remove prefix
+        @function = @input.sub("transform.", "")
+
+        raise InvalidTransformFunctionError, input unless TRANSFORM_METHODS.include?(function)
+
+        prepare_arguments!
+      end
+
+      def value
+        case function
+        when "join"
+          # Technically supports any attribute, but I ain't gonna test all them edge cases
+          arguments[:positional].resolve.join
+        end
+      end
+    end
+  end
+end

data/lib/spec_forge/attribute/variable.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module SpecForge
+  class Attribute
+    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
+
+      def bind_variables(variables)
+        raise InvalidTypeError.new(variables, Hash, for: "'variables'") unless Type.hash?(variables)
+
+        # Don't nil check here.
+        raise MissingVariableError, variable_name unless variables.key?(variable_name)
+
+        @base_object = variables[variable_name]
+
+        self
+      end
+    end
+  end
+end