action_factory 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 45042f5597609edaa5fbf3a24b85f970f67718a99072f32fbb4b2ec3a331eb42
+  data.tar.gz: 9f09d6f30142805d35c36940811c46a0c1bfe4c392edd4cffef3e2fddd372511
+SHA512:
+  metadata.gz: '008726cf59ddd69261213220f38887d9baca503e14c9db2aac61cf96fdadaa185e04ce2c34602c4365ed49f1c306ad3c7fbeb98d58acf88ad47a45805f8cf980'
+  data.tar.gz: 7db5bfe669686ce793af26aab8927f0b3ee7e168f4ae2411fa10adf7335c228dc91a0b2dd4a303423539e64e90cff5903cdfc12dd8023c41b0e6e39ed118de2e

data/README.md

@@ -0,0 +1,81 @@
+# ActionFactory
+A Simple OOO Factory lib for Ruby (and Rails)
+
+## Usage
+
+### Setup
+Create a base factory class
+```ruby
+class ApplicationFactory < ActionFactory::Base
+end
+```
+
+If you're using `ActiveRecord`, add the `association` helpers
+```ruby
+class ApplicationFactory < ActionFactory::Base
+  include ActionFactory::ActiveRecord
+end
+```
+
+### Creating your first factory
+```ruby
+class UserFactory < ApplicationFactory
+  attribute(:name) { "Hank Green" }
+  sequence(:email) { |i| "hgreen#{i}@example.com" }
+
+  trait(:activated) do
+    instance.activate!
+  end
+end
+```
+
+### Callbacks
+`ActionFactory::Base` uses `ActiveModel::Callbacks` to add the following lifecycle events:
+```
+after_initialize
+before_assign_attributes
+around_assign_attributes
+after_assign_attributes
+before_create
+around_create
+after_create
+```
+
+For example
+```ruby
+class MyModelFactory < ApplicationFactory
+  after_initialize :do_the_thing
+
+  private
+
+  def do_the_thing
+    instance.some_attribute = true if attributes[:some_attribute].blank?
+  end
+end
+```
+
+### Including helpers
+You can use `ActionFactory::Helpers` to call `create(:my_factory_name)` and `build(:my_factory_name)`.
+Here's an example for setting it up with RSpec:
+```ruby
+RSpec.configure do |config|
+  config.include ActionFactory::Helpers
+end
+```
+
+## Installation
+Via bundler:
+```bash
+bundle add action_factory
+```
+
+Or install it yourself as:
+```bash
+$ gem install action_factory
+```
+
+## Contributing
+Contributions welcome
+
+## License
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,3 @@
+require "bundler/setup"
+
+require "bundler/gem_tasks"

data/lib/action_factory/active_record.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/hash/indifferent_access"
+
+require "action_factory/runner"
+
+module ActionFactory
+  module ActiveRecord
+
+    class Association
+      def initialize(strategy:, factory_name:, traits:, block:)
+        @strategy = strategy
+        @factory_name = factory_name
+        @traits = traits
+        @block = block
+      end
+
+      def generate(strategy)
+        @block ? @block.call(runner) : runner.run(strategy)
+      end
+
+      def runner
+        @runner ||= ActionFactory::Runner.new(@factory_name, *@traits, strategy: @strategy)
+      end
+    end
+
+    def self.included(base)
+      base.extend ClassMethods
+      base.class_exec do
+        after_assign_attributes :build_associations
+      end
+    end
+
+    module ClassMethods
+      def associations
+        @associations ||= {}.with_indifferent_access
+      end
+
+      def association(name, strategy: nil, factory: name, traits: [], &block)
+        associations[name] = Association.new(strategy:, factory_name: factory, traits:, block:)
+      end
+    end
+
+    private
+
+    def build_associations
+      self.class.associations.except(*@attributes.keys).each do |name, association|
+        associated_record = association.generate(@strategy)
+        @instance.association(name).writer(associated_record)
+      end
+    end
+
+  end
+end

data/lib/action_factory/assignment_compiler.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module ActionFactory
+  class AssignmentCompiler
+
+    def initialize(factory)
+      @factory = factory
+    end
+
+    def compile(assignments, only: nil, except: [])
+      if only.present? && except.present?
+        raise ArgumentError, "Cannot use both 'only' and 'except' options"
+      end
+
+      assignments = assignments.slice(*only) unless only.nil?
+
+      assignments.except(*except).transform_values do |assignment|
+        assignment.compile(@factory)
+      end
+    end
+
+  end
+end

data/lib/action_factory/assignments/attribute.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module ActionFactory
+  module Assignments
+    class Attribute
+      def initialize(block)
+        @block = block
+      end
+
+      def compile(factory)
+        factory.instance_exec(&@block)
+      end
+    end
+  end
+end

data/lib/action_factory/assignments/sequence.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module ActionFactory
+  module Assignments
+    class Sequence
+      def initialize(block)
+        @count = 0
+        @block = block
+      end
+
+      def compile(factory)
+        # @count += 1
+        factory.instance_exec(@count += 1, &@block)
+      end
+    end
+  end
+end

data/lib/action_factory/assignments/trait.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module ActionFactory
+  module Assignments
+    class Trait
+      def initialize(block)
+        @block = block
+      end
+
+      def compile(factory)
+        factory.instance_exec(factory.instance, &@block)
+      end
+    end
+  end
+end

data/lib/action_factory/assignments.rb

@@ -0,0 +1,3 @@
+require "action_factory/assignments/attribute"
+require "action_factory/assignments/sequence"
+require "action_factory/assignments/trait"

data/lib/action_factory/attribute_assigner.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module ActionFactory
+  class AttributeAssigner
+
+    def initialize(instance)
+      @instance = instance
+    end
+
+    def assign(attributes)
+      attributes.each do |name, value|
+        @instance.public_send("#{name}=", value)
+      end
+    end
+
+  end
+end

data/lib/action_factory/base.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/hash/indifferent_access"
+require "active_support/core_ext/module/delegation"
+require "active_support/core_ext/object/deep_dup"
+
+require "active_model/callbacks"
+
+require "action_factory/assignment_compiler"
+require "action_factory/attribute_assigner"
+require "action_factory/assignments"
+
+module ActionFactory
+  class Base
+    extend ActiveModel::Callbacks
+
+    define_model_callbacks :initialize, only: [:after]
+    define_model_callbacks :assign_attributes, :create
+
+    ClassNotFound = Class.new(StandardError)
+
+    class << self
+      attr_reader :initializer, :creator
+
+      def factory(name)
+        Registry.register(name, self.name)
+      end
+
+      def class_name(name)
+        @klass_name = name
+      end
+
+      def klass_name
+        @klass_name ||= name.delete_suffix('Factory')
+      end
+
+      def klass
+        @klass ||= klass_name.constantize
+      rescue NameError
+        raise ClassNotFound, "Class with name #{class_name.inspect} not found"
+      end
+
+      def to_initialize(&block)
+        raise ArgumentError, 'Block required' unless block_given?
+        @initializer = block
+      end
+
+      def to_create(&block)
+        raise ArgumentError, 'Block required' unless block_given?
+        @creator = block
+      end
+
+      def attribute(name, &block)
+        assignments[:attributes][name] = ActionFactory::Assignments::Attribute.new(block)
+      end
+
+      def sequence(name, &block)
+        assignments[:attributes][name] = ActionFactory::Assignments::Sequence.new(block)
+      end
+
+      def trait(name, &block)
+        assignments[:traits][name] = ActionFactory::Assignments::Trait.new(block)
+      end
+
+      def assignments
+        @assignments ||= begin
+          if self.superclass.respond_to?(:assignments)
+            self.superclass.assignments.deep_dup
+          else
+            ActiveSupport::HashWithIndifferentAccess.new { |hash, key| hash[key] = {}.with_indifferent_access }
+          end
+        end
+      end
+    end
+
+    delegate :initializer, :creator, :klass, :assignments, to: :class
+
+    attr_reader :traits, :attributes, :instance
+
+    def initialize(*traits, **attributes)
+      @traits = traits
+      @attributes = attributes
+      @instance = build_instance_with_callbacks
+    end
+
+    def run(strategy)
+      @strategy = strategy
+      public_send(@strategy)
+    end
+
+    def build
+      run_callbacks :assign_attributes do
+        assign_attributes
+      end
+      instance
+    end
+
+    def create
+      build
+      run_callbacks :create do
+        persist_instance
+      end
+      instance
+    end
+
+    def factory_attributes
+      @factory_attributes ||= assignment_compiler.compile(assignments[:attributes], except: @attributes.keys)
+    end
+
+    private
+
+    def build_instance_with_callbacks
+      run_callbacks :initialize do
+        build_instance
+      end
+    end
+
+    def build_instance
+      return klass.class_exec(self, &initializer) if initializer
+
+      klass.public_send(ActionFactory.configuration.initialize_method)
+    end
+
+    def persist_instance
+      return @instance.instance_exec(self, &creator) if creator
+
+      @instance.public_send(ActionFactory.configuration.persist_method)
+    end
+
+    def assign_attributes
+      attribute_assigner.assign(@attributes)
+      attribute_assigner.assign(factory_attributes)
+      assignment_compiler.compile(assignments[:traits], only: @traits)
+    end
+
+    def assignment_compiler
+      @assignment_compiler ||= AssignmentCompiler.new(self)
+    end
+
+    def attribute_assigner
+      @attribute_assigner ||= AttributeAssigner.new(instance)
+    end
+  end
+end

data/lib/action_factory/factory_finder.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "action_factory/registry"
+
+module ActionFactory
+  class FactoryFinder
+    FactoryNotFound = Class.new(StandardError)
+
+    class << self
+      def factory_class_for(name)
+        new(name).factory_class
+      end
+    end
+
+    def initialize(name)
+      @name = name
+    end
+
+    def factory_class
+      factory_class_name = Registry.factory_class_name(@name)
+      factory_class_name.constantize
+    rescue NameError
+      raise FactoryNotFound, "Factory with class name #{factory_class_name.inspect} not found"
+    end
+  end
+end

data/lib/action_factory/helpers.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+# require "action_factory/factory_finder"
+require "action_factory/runner"
+
+module ActionFactory
+  module Helpers
+    def build(factory_name, *traits, **attributes)
+      ActionFactory::Runner.run(factory_name, *traits, strategy: :build, **attributes)
+    end
+
+    def create(factory_name, *traits, **attributes)
+      ActionFactory::Runner.run(factory_name, *traits, strategy: :create, **attributes)
+    end
+  end
+end

data/lib/action_factory/registry.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/string/inflections"
+
+module ActionFactory
+  module Registry
+    class << self
+      def register(factory_name, factory_class_name)
+        factories[factory_name.to_sym] = factory_class_name
+      end
+
+      def factories
+        @factories ||= Hash.new { |factories, name| factories[name.to_sym] = name.to_s.classify }
+      end
+
+      def factory_class_name(factory_name)
+        "#{class_name(factory_name)}Factory"
+      end
+
+      def class_name(factory_name)
+        factories[factory_name.to_sym]
+      end
+    end
+  end
+end

data/lib/action_factory/runner.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/module/delegation"
+
+require "action_factory/factory_finder"
+
+module ActionFactory
+  class Runner
+    class << self
+      def run(...)
+        new(...).run
+      end
+    end
+
+    attr_reader :factory, :factory_name, :strategy
+    delegate :traits, :attributes, to: :factory
+
+    def initialize(factory_name, *traits, strategy: nil, **attributes)
+      @factory_name = factory_name
+      @strategy = strategy
+      factory_class = FactoryFinder.factory_class_for(@factory_name)
+      @factory = factory_class.new(*traits, **attributes)
+    end
+
+    def run(strategy = nil)
+      @factory.run(strategy || @strategy)
+    end
+  end
+end

data/lib/action_factory/version.rb

@@ -0,0 +1,3 @@
+module ActionFactory
+  VERSION = "0.1.1"
+end

data/lib/action_factory.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "active_support"
+
+require "action_factory/version"
+require "action_factory/helpers"
+require "action_factory/base"
+
+module ActionFactory
+  class Configuration
+    attr_accessor :persist_method, :initialize_method
+
+    def initialize
+      @persist_method = :save!
+      @initialize_method = :new
+    end
+  end
+
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration)
+    end
+  end
+end

data/spec/action_factory/assignment_compiler_spec.rb

@@ -0,0 +1,66 @@
+require "spec_helper"
+
+RSpec.describe ActionFactory::AssignmentCompiler do
+  let(:factory) { double }
+
+  subject(:compiler) { described_class.new(factory) }
+
+  describe "#compile" do
+    let(:name_attribute_assignment) { instance_double(ActionFactory::Assignments::Attribute) }
+    let(:uid_sequence_assignment) { instance_double(ActionFactory::Assignments::Sequence) }
+    let(:unique_trait_assignment) { instance_double(ActionFactory::Assignments::Sequence) }
+    let(:assignments) do
+      {
+        name: name_attribute_assignment,
+        uid: uid_sequence_assignment,
+        unique: unique_trait_assignment
+      }
+    end
+    let(:name) { "John" }
+    let(:uid) { "123" }
+    let(:unique) { "unique" }
+
+    let(:expected_attributes) do
+      {
+        name: name,
+        uid: uid,
+        unique: unique
+      }
+    end
+
+    it "compiles the assignments" do
+      assignments.each do |key, assignment|
+        expect(assignment).to receive(:compile).with(factory).and_return(send(key))
+      end
+      expect(compiler.compile(assignments)).to eq(expected_attributes)
+    end
+
+    context "when 'only' is given" do
+      let(:only) { [:name] }
+
+      it "compiles only the given assignments" do
+        expect(name_attribute_assignment).to receive(:compile).with(factory).and_return(name)
+        expect(compiler.compile(assignments, only: only)).to eq(name: name)
+      end
+    end
+
+    context "when 'except' is given" do
+      let(:except) { [:name] }
+
+      it "compiles all except the given assignments" do
+        expect(uid_sequence_assignment).to receive(:compile).with(factory).and_return(uid)
+        expect(unique_trait_assignment).to receive(:compile).with(factory).and_return(unique)
+        expect(compiler.compile(assignments, except: except)).to eq(uid: uid, unique: unique)
+      end
+    end
+
+    context "when both 'only' and 'except' are given" do
+      let(:only) { [:name] }
+      let(:except) { [:uid] }
+
+      it "raises an ArgumentError" do
+        expect { compiler.compile(assignments, only: only, except: except) }.to raise_error(ArgumentError)
+      end
+    end
+  end
+end

data/spec/action_factory/attribute_assigner_spec.rb

@@ -0,0 +1,16 @@
+require "spec_helper"
+
+RSpec.describe ActionFactory::AttributeAssigner do
+  let(:instance) { double }
+
+  subject(:assigner) { described_class.new(instance) }
+
+  describe "#assign" do
+    let(:attributes) { { name: "John" } }
+
+    it "assigns the attributes to the instance" do
+      expect(instance).to receive(:name=).with("John")
+      assigner.assign(attributes)
+    end
+  end
+end

data/spec/action_factory/factory_finder_spec.rb

@@ -0,0 +1,38 @@
+require "spec_helper"
+
+RSpec.describe ActionFactory::FactoryFinder do
+  describe ".factory_class_for" do
+    let(:factory_class) { Class.new(ActionFactory::Base) }
+
+    before do
+      stub_const("UserFactory", factory_class)
+    end
+
+    it "returns the factory class for the given name" do
+      expect(described_class.factory_class_for(:user)).to eq(factory_class)
+    end
+  end
+
+  describe "#factory_class" do
+    let(:factory_class) { Class.new(ActionFactory::Base) }
+    let(:factory_name) { :user }
+
+    before do
+      stub_const("UserFactory", factory_class)
+    end
+
+    subject(:factory_finder) { described_class.new(factory_name) }
+
+    it "returns the factory class for the given name" do
+      expect(factory_finder.factory_class).to eq(factory_class)
+    end
+
+    context "when the factory class is not found" do
+      let(:factory_name) { :foo }
+
+      it "raises an error" do
+        expect { factory_finder.factory_class }.to raise_error(ActionFactory::FactoryFinder::FactoryNotFound)
+      end
+    end
+  end
+end

data/spec/action_factory/registry_spec.rb

@@ -0,0 +1,45 @@
+require "spec_helper"
+
+RSpec.describe ActionFactory::Registry do
+  let(:factory_name) { :user }
+  let(:model_name) { "CustomUser" }
+  let(:default_factory_class_name) { "UserFactory" }
+  let(:expected_factory_class_name) { "CustomUserFactory" }
+
+  describe ".register" do
+    subject(:register) { described_class.register(factory_name, model_name) }
+
+    it "registers the factory class name for the given factory name" do
+      expect { register }.to(
+        change { described_class.factory_class_name(factory_name) }.from(
+          default_factory_class_name
+        ).to(
+          expected_factory_class_name
+        )
+      )
+    end
+  end
+
+  describe ".factories" do
+    subject { described_class.factories }
+
+    it { is_expected.to be_a(Hash) }
+
+    it "returns a hash with default values" do
+      expect(subject.default_proc).to be_a(Proc)
+      expect(subject[:foo]).to eq("Foo")
+    end
+  end
+
+  describe ".factory_class_name" do
+    before do
+      described_class.register(factory_name, model_name)
+    end
+
+    subject(:factory_class_name) { described_class.factory_class_name(factory_name) }
+
+    it "returns the factory class name for the given factory name" do
+      expect(factory_class_name).to eq(expected_factory_class_name)
+    end
+  end
+end

data/spec/action_factory/runner_spec.rb

@@ -0,0 +1,36 @@
+require "spec_helper"
+
+RSpec.describe ActionFactory::Runner do
+  describe "#run" do
+    let(:factory_class) { Class.new(ActionFactory::Base) }
+    let(:factory_name) { :user }
+    let(:attributes) { { name: "John" } }
+    let(:traits) { [:admin] }
+    let(:factory) { instance_double(ActionFactory::Base) }
+    let(:instance) { double }
+
+    before do
+      stub_const("UserFactory", factory_class)
+      allow(ActionFactory::FactoryFinder).to receive(:factory_class_for).with(factory_name).and_return(factory_class)
+      allow(factory_class).to receive(:new).with(*traits, **attributes).and_return(factory)
+    end
+
+    subject(:runner) { described_class.new(factory_name, *traits, **attributes) }
+
+    it "runs the factory" do
+      allow(factory).to receive(:run).with(nil).and_return(instance)
+      expect(runner.run).to eq(instance)
+    end
+
+    context "when a strategy is given" do
+      subject(:runner) { described_class.new(factory_name, *traits, strategy: strategy, **attributes) }
+
+      let(:strategy) { :create }
+
+      it "runs the factory with the given strategy" do
+        allow(factory).to receive(:run).with(strategy).and_return(instance)
+        expect(runner.run(strategy)).to eq(instance)
+      end
+    end
+  end
+end

data/spec/action_factory_spec.rb

@@ -0,0 +1,37 @@
+require "spec_helper"
+
+RSpec.describe ActionFactory do
+  it "has a version number" do
+    expect(ActionFactory::VERSION).to eq "0.1.1"
+  end
+
+  describe ".configuration" do
+    subject { described_class.configuration }
+
+    it { is_expected.to be_a(ActionFactory::Configuration) }
+  end
+
+  describe ".configure" do
+    subject(:configure) { described_class.configure { |config| config.persist_method = :save } }
+
+    it "configures the gem" do
+      expect { configure }.to change { described_class.configuration.persist_method }.from(:save!).to(:save)
+    end
+  end
+
+  describe ActionFactory::Configuration do
+    subject(:configuration) { described_class.new }
+
+    describe "#persist_method" do
+      subject { configuration.persist_method }
+
+      it { is_expected.to eq :save! }
+    end
+
+    describe "#initialize_method" do
+      subject { configuration.initialize_method }
+
+      it { is_expected.to eq :new }
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,97 @@
+ENV["RAILS_ENV"] ||= "test"
+
+require "action_factory"
+# This file was generated by the `rails generate rspec:install` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause
+# this file to always be loaded, without a need to explicitly require it in any
+# files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need
+# it.
+#
+# See https://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+  # This option will default to `:apply_to_host_groups` in RSpec 4 (and will
+  # have no way to turn it off -- the option exists only for backwards
+  # compatibility in RSpec 3). It causes shared context metadata to be
+  # inherited by the metadata hash of host groups and examples, rather than
+  # triggering implicit auto-inclusion in groups with matching metadata.
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+=begin
+  # This allows you to limit a spec run to individual examples or groups
+  # you care about by tagging them with `:focus` metadata. When nothing
+  # is tagged with `:focus`, all examples get run. RSpec also provides
+  # aliases for `it`, `describe`, and `context` that include `:focus`
+  # metadata: `fit`, `fdescribe` and `fcontext`, respectively.
+  config.filter_run_when_matching :focus
+
+  # Allows RSpec to persist some state between runs in order to support
+  # the `--only-failures` and `--next-failure` CLI options. We recommend
+  # you configure your source control system to ignore this file.
+  config.example_status_persistence_file_path = "spec/examples.txt"
+
+  # Limits the available syntax to the non-monkey patched syntax that is
+  # recommended. For more details, see:
+  # https://rspec.info/features/3-12/rspec-core/configuration/zero-monkey-patching-mode/
+  config.disable_monkey_patching!
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = "doc"
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+=end
+end

metadata

@@ -0,0 +1,144 @@
+--- !ruby/object:Gem::Specification
+name: action_factory
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Ben Loyola
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-07-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.0.6
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.0.6
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.0.6
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.0.6
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: debug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+description: Your factories are now classes.
+email:
+- berna.loyola@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- Rakefile
+- lib/action_factory.rb
+- lib/action_factory/active_record.rb
+- lib/action_factory/assignment_compiler.rb
+- lib/action_factory/assignments.rb
+- lib/action_factory/assignments/attribute.rb
+- lib/action_factory/assignments/sequence.rb
+- lib/action_factory/assignments/trait.rb
+- lib/action_factory/attribute_assigner.rb
+- lib/action_factory/base.rb
+- lib/action_factory/factory_finder.rb
+- lib/action_factory/helpers.rb
+- lib/action_factory/registry.rb
+- lib/action_factory/runner.rb
+- lib/action_factory/version.rb
+- spec/action_factory/assignment_compiler_spec.rb
+- spec/action_factory/attribute_assigner_spec.rb
+- spec/action_factory/factory_finder_spec.rb
+- spec/action_factory/registry_spec.rb
+- spec/action_factory/runner_spec.rb
+- spec/action_factory_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/b-loyola/action_factory
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/b-loyola/action_factory
+  source_code_uri: https://github.com/b-loyola/action_factory
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.10
+signing_key:
+specification_version: 4
+summary: A Simple OOO Factory lib for Ruby (and Rails)
+test_files:
+- spec/action_factory/assignment_compiler_spec.rb
+- spec/action_factory/attribute_assigner_spec.rb
+- spec/action_factory/factory_finder_spec.rb
+- spec/action_factory/registry_spec.rb
+- spec/action_factory/runner_spec.rb
+- spec/action_factory_spec.rb
+- spec/spec_helper.rb