action_factory 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aaf7d716e62d35a452721dfd65df98d7ce8cf7aed8109bb1ddcc5e66e886ebf7
-  data.tar.gz: e2bd6267050b1b2cdce65a2f1efffdf6bd8de23e46388e4cbd27e89fd0e0dee9
+  metadata.gz: 4a1c5d74820ed98b22f20bc0a5e067d1c44e699c5cd409072413ff06cd947ab1
+  data.tar.gz: f543f0cb2ec678381a734d4e1424fb4afd5bfd7a3a00ada461c3072bb1a2c9ea
 SHA512:
-  metadata.gz: 56e383ded141a98cbffd0ba3d5eaa7d7a5e07fc0c62efbaaa29d0161240e9700b6917ea2b9ff397ea1c7442a511874d175fee59351a6efaa42b47843f84efe5b
-  data.tar.gz: 0f408971e27baa3a655cb34f2e4a6fd137d3cdd23c8f33c2dae25441bb27aa2eec06e68d3aa070524ef01ccf33045279becba411ca46f5bf9aa97451742b623a
+  metadata.gz: 8cbd4f57421075eea4cbed63fb4c690868c600ff0eaa61ceeae44923f3dd05554e3f5995c682c711a441eea0707793a53077f6078c02a4ecfb9226a4a9acf688
+  data.tar.gz: 2c1f35b170f5c75530536de81bb1e55de0f3d6ed39a6d490bc698c1e842575da02adc1d6ca1c02e021cc19d35503c7cfe276a385f51e658d04d7593311a11390

data/lib/action_factory/active_record.rb

@@ -27,7 +27,7 @@ module ActionFactory
     def self.included(base)
       base.extend ClassMethods
       base.class_exec do
-        after_assign_attributes :build_associations
+        before_assign_attributes :build_associations
       end
     end
 
@@ -46,7 +46,7 @@ module ActionFactory
     def build_associations
       self.class.associations.except(*@attributes.keys).each do |name, association|
         associated_record = association.generate(@strategy)
-        @instance.association(name).writer(associated_record)
+        @instance.association(name.to_sym).writer(associated_record)
       end
     end
 

data/lib/action_factory/assignments/attribute.rb

@@ -3,6 +3,8 @@
 module ActionFactory
   module Assignments
     class Attribute
+      attr_reader :block
+
       def initialize(block)
         @block = block
       end
@@ -10,6 +12,10 @@ module ActionFactory
       def compile(factory)
         factory.instance_exec(&@block)
       end
+
+      def ==(other)
+        other.is_a?(self.class) && other.block == @block
+      end
     end
   end
 end

data/lib/action_factory/assignments/sequence.rb

@@ -3,15 +3,20 @@
 module ActionFactory
   module Assignments
     class Sequence
+      attr_reader :block, :count
+
       def initialize(block)
-        @count = 0
         @block = block
+        @count = 0
       end
 
       def compile(factory)
-        # @count += 1
         factory.instance_exec(@count += 1, &@block)
       end
+
+      def ==(other)
+        other.is_a?(self.class) && other.block == @block && other.count == @count
+      end
     end
   end
 end

data/lib/action_factory/assignments/trait.rb

@@ -3,6 +3,8 @@
 module ActionFactory
   module Assignments
     class Trait
+      attr_reader :block
+
       def initialize(block)
         @block = block
       end
@@ -10,6 +12,10 @@ module ActionFactory
       def compile(factory)
         factory.instance_exec(factory.instance, &@block)
       end
+
+      def ==(other)
+        other.is_a?(self.class) && other.block == @block
+      end
     end
   end
 end

data/lib/action_factory/base.rb

@@ -22,22 +22,22 @@ module ActionFactory
     class << self
       attr_reader :initializer, :creator
 
-      def factory(name)
-        Registry.register(name, self.name)
-      end
+      def register(factory_name: nil, class_name: nil)
+        raise ArgumentError, 'factory_name or class_name required' unless factory_name || class_name
 
-      def class_name(name)
-        @klass_name = name
+        Registry.register(factory_class_name: self.name, factory_name: factory_name, class_name: class_name)
       end
 
-      def klass_name
-        @klass_name ||= name.delete_suffix('Factory')
+      def class_name
+        Registry.class_name_for(self.name)
       end
 
       def klass
-        @klass ||= klass_name.constantize
+        @klass ||= class_name.constantize
       rescue NameError
-        raise ClassNotFound, "Class with name #{class_name.inspect} not found"
+        message = "Class with name #{class_name.inspect} not found, " \
+                  "please use `register` if you need to configure a custom class name"
+        raise ClassNotFound, message
       end
 
       def to_initialize(&block)
@@ -75,12 +75,13 @@ module ActionFactory
 
     delegate :initializer, :creator, :klass, :assignments, to: :class
 
-    attr_reader :traits, :attributes, :instance
+    attr_reader :traits, :attributes
 
     def initialize(*traits, **attributes)
+      raise "cannot initialize base class" if self.class == ActionFactory::Base
+
       @traits = traits
       @attributes = attributes
-      @instance = build_instance_with_callbacks
     end
 
     def run(strategy)
@@ -89,6 +90,7 @@ module ActionFactory
     end
 
     def build
+      instance
       run_callbacks :assign_attributes do
         assign_attributes
       end
@@ -107,6 +109,10 @@ module ActionFactory
       @factory_attributes ||= assignment_compiler.compile(assignments[:attributes], except: @attributes.keys)
     end
 
+    def instance
+      @instance ||= build_instance_with_callbacks
+    end
+
     private
 
     def build_instance_with_callbacks
@@ -122,9 +128,9 @@ module ActionFactory
     end
 
     def persist_instance
-      return @instance.instance_exec(self, &creator) if creator
+      return instance.instance_exec(self, &creator) if creator
 
-      @instance.public_send(ActionFactory.configuration.persist_method)
+      instance.public_send(ActionFactory.configuration.persist_method)
     end
 
     def assign_attributes

data/lib/action_factory/factory_finder.rb

@@ -17,7 +17,7 @@ module ActionFactory
     end
 
     def factory_class
-      factory_class_name = Registry.factory_class_name(@name)
+      factory_class_name = Registry.factory_class_name_for(@name)
       factory_class_name.constantize
     rescue NameError
       raise FactoryNotFound, "Factory with class name #{factory_class_name.inspect} not found"

data/lib/action_factory/registry.rb

@@ -3,23 +3,64 @@
 require "active_support/core_ext/string/inflections"
 
 module ActionFactory
-  module Registry
+  class Registry
     class << self
-      def register(factory_name, factory_class_name)
-        factories[factory_name.to_sym] = factory_class_name
+      delegate :register, :factory_class_name_for, :class_name_for, to: :instance
+
+      def instance
+        @instance ||= new
       end
 
-      def factories
-        @factories ||= Hash.new { |factories, name| factories[name.to_sym] = name.to_s.classify }
+      def clear
+        @instance = nil
       end
+    end
 
-      def factory_class_name(factory_name)
-        "#{class_name(factory_name)}Factory"
+    def initialize
+      @class_name_by_factory_class_name = Hash.new do |class_names, factory_class_name|
+        class_names[factory_class_name.to_s] = factory_class_name.delete_suffix("Factory")
+      end
+      @class_name_by_symbol = Hash.new do |class_names, symbol|
+        class_names[symbol.to_sym] = symbol.to_s.classify
       end
+      @factories_by_class_name = Hash.new do |factories, class_name|
+        factories[class_name.to_s] = "#{class_name}Factory"
+      end
+    end
 
-      def class_name(factory_name)
-        factories[factory_name.to_sym]
+    def register(factory_class_name:, factory_name: nil, class_name: nil)
+      class_name ||= factory_class_name.to_s.chomp("Factory")
+      factory_name ||= class_name.underscore
+      @class_name_by_factory_class_name[factory_class_name.to_s] = class_name
+      @class_name_by_symbol[factory_name.to_sym] = class_name
+      @factories_by_class_name[class_name.to_s] = factory_class_name
+    end
+
+    def factory_class_name_for(name)
+      case name
+      when Symbol
+        # Presume that the symbol is a factory name
+        @factories_by_class_name[class_name_for(name)]
+      when Class, String
+        # Presume that classes and strings are a model classes
+        @factories_by_class_name[name.to_s]
+      else
+        raise ArgumentError, "Invalid argument type #{name.class}"
       end
     end
+
+    def class_name_for(name)
+      case name
+      when Symbol
+        # Presume that symbols are factory names
+        @class_name_by_symbol[name]
+      when String, Class
+        # Presume that strings and classes are for factory class names
+        @class_name_by_factory_class_name[name.to_s]
+      else
+        raise ArgumentError, "Invalid argument type #{name.class}"
+      end
+    end
+
   end
 end

data/lib/action_factory/version.rb

@@ -1,3 +1,3 @@
 module ActionFactory
-  VERSION = "0.1.2"
+  VERSION = "0.1.3"
 end

data/spec/action_factory/base_spec.rb

@@ -0,0 +1,281 @@
+require "spec_helper"
+require "ostruct"
+
+RSpec.describe ActionFactory::Base do
+  let(:factory_class_name) { "FooFactory" }
+  let(:class_name) { "Foo" }
+  let(:factory_class) { Class.new(described_class) }
+  let(:factory_instance) { factory_class.new(*traits, **attributes) }
+  let(:traits) { [] }
+  let(:attributes) { {} }
+  let(:factory_class_with_attributes) do
+    Class.new(described_class) do
+      attribute(:foo) { "foo" }
+      sequence(:bar) { |i| "bar-#{i}" }
+      trait(:baz) { self.baz = "baz" }
+    end
+  end
+
+  before do
+    stub_const(factory_class_name, factory_class)
+  end
+
+  after do
+    ActionFactory::Registry.clear
+  end
+
+  describe ".register" do
+    context "when no arguments are provided" do
+      it "raises an error" do
+        expect { factory_class.register }.to raise_error(ArgumentError)
+      end
+    end
+
+    context "when factory_name is provided" do
+      let(:factory_name) { :foobar }
+
+      it "registers the factory" do
+        expect { factory_class.register(factory_name: :foobar) }.to(
+          change { ActionFactory::Registry.factory_class_name_for(factory_name) }.from("FoobarFactory").to(factory_class_name)
+        )
+      end
+    end
+
+    context "when class_name is provided" do
+      let(:class_name) { "BarFoo" }
+
+      it "registers the factory" do
+        expect { factory_class.register(class_name: class_name) }.to change {
+          ActionFactory::Registry.factory_class_name_for(class_name)
+        }.from("BarFooFactory").to(factory_class_name)
+      end
+    end
+
+    context "when factory_name and class_name are provided" do
+      let(:factory_name) { :baz }
+      let(:class_name) { "Bar" }
+      it "registers the factory" do
+        expect { factory_class.register(factory_name: :baz, class_name: "Bar") }.to(
+          change { ActionFactory::Registry.factory_class_name_for(factory_name) }.from("BazFactory").to(factory_class_name).and(
+            change { ActionFactory::Registry.factory_class_name_for(class_name) }.from("BarFactory").to(factory_class_name)
+          )
+        )
+      end
+    end
+  end
+
+  describe ".klass" do
+    context "when the model class does not exist" do
+      it "raises an error" do
+        expect { factory_class.klass }.to raise_error(ActionFactory::Base::ClassNotFound)
+      end
+    end
+
+    context "when the model class exists" do
+      let(:klass) { Class.new }
+
+      before do
+        stub_const(class_name, klass)
+      end
+
+      it "returns the class" do
+        expect(factory_class.klass).to eq(klass)
+      end
+    end
+  end
+
+  describe ".to_initialize" do
+    context "when no block is provided" do
+      it "raises an error" do
+        expect { factory_class.to_initialize }.to raise_error(ArgumentError)
+      end
+    end
+
+    context "when a block is provided" do
+      it "sets the initializer" do
+        proc = Proc.new { }
+        factory_class.to_initialize(&proc)
+        expect(factory_class.initializer).to eq(proc)
+      end
+    end
+  end
+
+  describe ".to_create" do
+    context "when no block is provided" do
+      it "raises an error" do
+        expect { factory_class.to_create }.to raise_error(ArgumentError)
+      end
+    end
+
+    context "when a block is provided" do
+      it "sets the creator" do
+        proc = Proc.new { }
+        factory_class.to_create(&proc)
+        expect(factory_class.creator).to eq(proc)
+      end
+    end
+  end
+
+  describe ".attribute" do
+    subject(:attribute_assignment) { factory_class.attribute(name, &block) }
+    let(:name) { :foo }
+    let(:block) { Proc.new { "They're taking the hobbits to Isengard!" } }
+
+    it "adds the attribute to the assignments" do
+      expect { attribute_assignment }.to(
+        change { factory_class.assignments[:attributes] }.from({}).to(
+          { name => ActionFactory::Assignments::Attribute.new(block) }
+        )
+      )
+    end
+  end
+
+  describe ".sequence" do
+    subject(:sequence_assignment) { factory_class.sequence(name, &block) }
+    let(:name) { :bar }
+    let(:block) { Proc.new { "Tis but a scratch" } }
+
+    it "adds the sequence to the assignments" do
+      expect { sequence_assignment }.to(
+        change { factory_class.assignments[:attributes] }.from({}).to(
+          { name => ActionFactory::Assignments::Sequence.new(block) }
+        )
+      )
+    end
+  end
+
+  describe ".trait" do
+    subject(:trait_assignment) { factory_class.trait(name, &block) }
+    let(:name) { :baz }
+    let(:block) { Proc.new { "I'm not dead yet!" } }
+
+    it "adds the trait to the assignments" do
+      expect { trait_assignment }.to(
+        change { factory_class.assignments[:traits] }.from({}).to(
+          { name => ActionFactory::Assignments::Trait.new(block) }
+        )
+      )
+    end
+  end
+
+  describe ".assignments" do
+    subject(:assignments) { factory_class.assignments }
+
+    context "when no assignments have been made" do
+      it { is_expected.to eq({}) }
+
+      it "returns a hash with default proc" do
+        expect(assignments[:foo]).to be_a(ActiveSupport::HashWithIndifferentAccess)
+      end
+    end
+
+    context "when assignments have been made" do
+      let!(:attribute_assignment) { factory_class.attribute(:foo) { } }
+      let!(:sequence_assignment) { factory_class.sequence(:bar) { } }
+      let!(:trait_assignment) { factory_class.trait(:baz) { } }
+
+      it "returns the assignments" do
+        expect(assignments).to eq(
+          "attributes" => {
+            "foo" => attribute_assignment,
+            "bar" => sequence_assignment
+          },
+          "traits" => {
+            "baz" => trait_assignment
+          }
+        )
+      end
+    end
+
+    context "when assignments have been made in a parent class" do
+      let(:parent_factory_class) do
+        Class.new(described_class) do
+          attribute(:foo) { "foo" }
+          sequence(:bar) { "bar" }
+          trait(:baz) { "baz" }
+        end
+      end
+
+      let(:factory_class) do
+        Class.new(parent_factory_class) do
+          attribute(:qux) { "qux" }
+          sequence(:bar) { "other bar" }
+        end
+      end
+
+      it "returns the expected assignments" do
+        expect(factory_class.assignments).to eq(
+          "attributes" => {
+            "foo" => parent_factory_class.assignments[:attributes][:foo],
+            "bar" => factory_class.assignments[:attributes][:bar],
+            "qux" => factory_class.assignments[:attributes][:qux]
+          },
+          "traits" => {
+            "baz" => parent_factory_class.assignments[:traits][:baz]
+          }
+        )
+      end
+    end
+  end
+
+  describe "#initialize" do
+    context "when the class is ActionFactory::Base" do
+      it "raises an error" do
+        expect { described_class.new }.to raise_error("cannot initialize base class")
+      end
+    end
+
+    context "when the class is not ActionFactory::Base" do
+      it "does not raise an error" do
+        expect { factory_class.new }.not_to raise_error
+      end
+    end
+  end
+
+  describe "#run" do
+    context "when strategy is build" do
+      let(:strategy) { :build }
+
+      it "calls build" do
+        expect(factory_instance).to receive(:build)
+        factory_instance.run(strategy)
+      end
+    end
+
+    context "when strategy is create" do
+      let(:strategy) { :create }
+
+      it "calls create" do
+        expect(factory_instance).to receive(:create)
+        factory_instance.run(strategy)
+      end
+    end
+  end
+
+  describe "#build" do
+    subject(:build) { factory_instance.build }
+    let(:model_class) { Class.new(OpenStruct) }
+
+    before do
+      stub_const(class_name, model_class)
+    end
+
+    it "returns the instance" do
+      expect(build).to be_an_instance_of(model_class)
+    end
+
+    context "when the initializer is defined" do
+      let(:initializer) { Proc.new { } }
+      let(:built_instance) { instance_double(model_class) }
+
+      before do
+        factory_class.to_initialize(&initializer)
+      end
+
+      it "calls the initializer" do
+        expect(model_class).to receive(:class_exec).with(factory_instance, &initializer).and_return(built_instance)
+        expect(build).to eq(built_instance)
+      end
+    end
+  end
+end

data/spec/action_factory/registry_spec.rb

@@ -2,44 +2,152 @@ require "spec_helper"
 
 RSpec.describe ActionFactory::Registry do
   let(:factory_name) { :user }
-  let(:model_name) { "CustomUser" }
+  let(:default_class_name) { "User" }
+  let(:custom_class_name) { "CustomUser" }
   let(:default_factory_class_name) { "UserFactory" }
-  let(:expected_factory_class_name) { "CustomUserFactory" }
+  let(:custom_factory_class_name) { "SomeCustomUserFactory" }
+
+  after do
+    described_class.clear
+  end
 
   describe ".register" do
-    subject(:register) { described_class.register(factory_name, model_name) }
+    subject(:register) do
+      described_class.register(
+        factory_class_name: custom_factory_class_name,
+        factory_name: factory_name,
+        class_name: custom_class_name
+      )
+    end
 
     it "registers the factory class name for the given factory name" do
       expect { register }.to(
-        change { described_class.factory_class_name(factory_name) }.from(
+        change { described_class.factory_class_name_for(factory_name) }.from(
           default_factory_class_name
         ).to(
-          expected_factory_class_name
+          custom_factory_class_name
         )
       )
     end
   end
 
-  describe ".factories" do
-    subject { described_class.factories }
+  describe ".factory_class_name_for" do
+    subject(:factory_class_name_for) { described_class.factory_class_name_for(name) }
+
+    context "when the name is registered" do
+      before do
+        described_class.register(
+          factory_class_name: custom_factory_class_name,
+          factory_name: factory_name,
+          class_name: custom_class_name
+        )
+      end
+
+      context "when the name is a symbol" do
+        let(:name) { factory_name }
+
+        it { is_expected.to eq(custom_factory_class_name) }
+      end
+
+      context "when the name is a string" do
+        let(:name) { custom_class_name }
 
-    it { is_expected.to be_a(Hash) }
+        it { is_expected.to eq(custom_factory_class_name) }
+      end
 
-    it "returns a hash with default values" do
-      expect(subject.default_proc).to be_a(Proc)
-      expect(subject[:foo]).to eq("Foo")
+      context "when the name is a class" do
+        let(:name) { custom_class_name.constantize }
+
+        before do
+          stub_const(custom_class_name, Class.new)
+        end
+
+        it { is_expected.to eq(custom_factory_class_name) }
+      end
+    end
+
+    context "when the name is not registered" do
+      context "when the name is a symbol" do
+        let(:name) { factory_name }
+
+        it { is_expected.to eq(default_factory_class_name) }
+      end
+
+      context "when the name is a string" do
+        let(:name) { default_class_name }
+
+        it { is_expected.to eq(default_factory_class_name) }
+      end
+
+      context "when the name is a class" do
+        let(:name) { default_class_name.constantize }
+
+        before do
+          stub_const(default_class_name, Class.new)
+        end
+
+        it { is_expected.to eq(default_factory_class_name) }
+      end
     end
   end
 
-  describe ".factory_class_name" do
-    before do
-      described_class.register(factory_name, model_name)
+  describe ".class_name_for" do
+    subject(:class_name_for) { described_class.class_name_for(name) }
+
+    context "when the name is registered" do
+      before do
+        described_class.register(
+          factory_class_name: custom_factory_class_name,
+          factory_name: factory_name,
+          class_name: custom_class_name
+        )
+      end
+
+      context "when the name is a symbol" do
+        let(:name) { factory_name }
+
+        it { is_expected.to eq(custom_class_name) }
+      end
+
+      context "when the name is a string" do
+        let(:name) { custom_factory_class_name }
+
+        it { is_expected.to eq(custom_class_name) }
+      end
+
+      context "when the name is a class" do
+        let(:name) { custom_factory_class_name.constantize }
+
+        before do
+          stub_const(custom_factory_class_name, Class.new)
+        end
+
+        it { is_expected.to eq(custom_class_name) }
+      end
     end
 
-    subject(:factory_class_name) { described_class.factory_class_name(factory_name) }
+    context "when the name is not registered" do
+      context "when the name is a symbol" do
+        let(:name) { factory_name }
+
+        it { is_expected.to eq(default_class_name) }
+      end
+
+      context "when the name is a string" do
+        let(:name) { default_factory_class_name }
+
+        it { is_expected.to eq(default_class_name) }
+      end
+
+      context "when the name is a class" do
+        let(:name) { default_factory_class_name.constantize }
+
+        before do
+          stub_const(default_factory_class_name, Class.new)
+        end
 
-    it "returns the factory class name for the given factory name" do
-      expect(factory_class_name).to eq(expected_factory_class_name)
+        it { is_expected.to eq(default_class_name) }
+      end
     end
   end
 end

data/spec/action_factory_spec.rb

@@ -2,7 +2,7 @@ require "spec_helper"
 
 RSpec.describe ActionFactory do
   it "has a version number" do
-    expect(ActionFactory::VERSION).to eq "0.1.2"
+    expect(ActionFactory::VERSION).to eq "0.1.3"
   end
 
   describe ".configuration" do

data/spec/dummy/tmp/development_secret.txt

@@ -0,0 +1 @@
+92372a41d1c65de126fb2aff47f912ae3bc409b922905b1383518a048021d85050a3122a30078e7c72f95866f8c740d57c2a5b226a8bda3656f31024bdacf591

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: action_factory
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Ben Loyola
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-07-27 00:00:00.000000000 Z
+date: 2024-03-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -103,10 +103,13 @@ files:
 - lib/action_factory/version.rb
 - spec/action_factory/assignment_compiler_spec.rb
 - spec/action_factory/attribute_assigner_spec.rb
+- spec/action_factory/base_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/dummy/log/test.log
+- spec/dummy/tmp/development_secret.txt
 - spec/spec_helper.rb
 homepage: https://github.com/b-loyola/action_factory
 licenses:
@@ -130,15 +133,18 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
+rubygems_version: 3.5.6
 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/base_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/dummy/log/test.log
+- spec/dummy/tmp/development_secret.txt
 - spec/spec_helper.rb