fixture_record 0.1.2.pre.rc → 1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e0b73f48614260bc6e1dc1f0ecebcabe4b5bb44779eb3ba807be3942fd8439fc
-  data.tar.gz: 2af43ba19fd5cde723d3dede76fd21eecd17f92d1ad38693702d14fbd85939fa
+  metadata.gz: 725ff327350c904ec886ba1833e976a798e47d564aac8539dec6f2614d86f298
+  data.tar.gz: d820511bb21ee20a76c5e12109030e56bde60e3eab69c100248285d59dbb9047
 SHA512:
-  metadata.gz: 630ec0346571b9f9a35f2a1f319106e4041372a97e4da36980ac24038b2bc8a6f19fc64d6274813834a46a817d148cfdb3961cb9be5a9ede11a20dc7ba543b23
-  data.tar.gz: 1c5fa27c4b2bd560bee90fb1461d53a55fc64e380c7df15876b080b17eea315b7dc3290536b3217c758a6929477c2194766e7bb09d363607414f490c3f766d49
+  metadata.gz: 14a8530fe32a301bdc5bc4182da67fd8751823d0d43f3d9cd708e23a4c2d99c9b292f77c47043d1ddb79b4eb75f0326382f59425b37d3986e5143328a8ebd046
+  data.tar.gz: 90bf683053f43a2e0f7f73acb7b6a260ac2ae6748fbffb197fefc7c6fb5cdf1c7d0e6822baa558cdba82f4fbc7a7ab587882d841566a5833d5bcfb10fe379c80

data/README.md

@@ -1,12 +1,12 @@
 # FixtureRecord
-When it comes to testing, ActiveRecrod::Fixtures provide a huge performance benefit over FactoryBot but at the expense of setting up the necessary test data. For complex associations and relationships, a large amount of time might be spent simply trying to setup the data. FixtureRecord provides a `to_test_fixture` method that accepts a chain of associations as an argument that allows you to quickly turn a large collection of existing records into test fixtures.
+When it comes to testing, ActiveRecrod::Fixtures provide a huge performance benefit over FactoryBot but at the expense of setting up the necessary test data. For complex associations and relationships, a large amount of time might be spent simply trying to setup the data. FixtureRecord provides a `to_fixture_record` method that accepts a chain of associations as an argument that allows you to quickly turn a large collection of existing records into test fixtures.
 
 ## Usage
-`to_test_fixture` is a method that will turn the record into a test fixture. By default, the name of the fixture record will be `param_key` of the record's class and the record's id joined with `_`.
+`to_fixture_record` is a method that will turn the record into a test fixture. By default, the name of the fixture record will be `param_key` of the record's class and the record's id joined with `_`.
 
 ```ruby
 user = User.find(1)
-user.to_test_fixture
+user.to_fixture_record
 
 # creates test/fixtures/users.yml if it does not exists
 ```
@@ -41,7 +41,7 @@ Let's say an edge case bug has been found with a particular post and it's relate
 
 ```ruby
 edge_case_post = Post.find ...
-edge_case_post.to_test_fixture(:author, comments: :user)
+edge_case_post.to_fixture_record(:author, comments: :user)
 ```
 This would create a test fixture for the post, its author, all the comments on the post and their respective users. This will also change the `belongs_to` relationships in the yaml files to reflect their respective fixture counterparts. For example, if `Post#12` author is `User#49`,
 and the post has `Comment#27` the fixture records might look like:
@@ -63,7 +63,7 @@ comment_27:
   commentable: post_12 (Post)
 ```
 
-Note that these changes to the `belongs_to` associations is only applicable to records that are part of the associations that are being passed into `to_test_fixture`. So taking the same example as above, `edge_case_post.to_test_fixture` would yield the following:
+Note that these changes to the `belongs_to` associations is only applicable to records that are part of the associations that are being passed into `to_fixture_record`. So taking the same example as above, `edge_case_post.to_fixture_record` would yield the following:
 ```yaml
 post_12:
   author_id: 49
@@ -71,8 +71,8 @@ post_12:
 
 Currently, `FixtureRecord` will also not attempt to already existing fixtures to newly created data.
 ```ruby
-User.find(49).to_test_fixture
-Post.find(12).to_test_fixture
+User.find(49).to_fixture_record
+Post.find(12).to_fixture_record
 ```
 The above would yield fixtures that are not associated to one another.
 ```yaml
@@ -97,19 +97,19 @@ end
 ```
 Because of through association infilling the following 3 lines will produce identical results:
 ```ruby
-user.to_test_fixture(posts: [comments: :users])
+user.to_fixture_record(posts: [comments: :users])
 
-user.to_test_fixture(:posts, :post_comments, :commenting_users)
+user.to_fixture_record(:posts, :post_comments, :commenting_users)
 
 user.to_test_fixutre(:commenting_users)
 ```
 The reason the third example will infill the other associations is because those associations are required to create a clear path between the originating record and the final records. Without those intermediary associations, the `:commenting_users` would be orphaned from the `user` record.
 
 ### FixtureRecord::Naming
-There might be instances where a record was used for a particular test fixture and you want to use this same record again for a different test case but want to keep the data isolated. `FixtureRecord::Naming` (automatically included with FixtureRecord) provides`fixture_record_prefix` and `fixture_record_suffix`. These values are propagated to the associated records when calling `to_test_fixture`.
+There might be instances where a record was used for a particular test fixture and you want to use this same record again for a different test case but want to keep the data isolated. `FixtureRecord::Naming` (automatically included with FixtureRecord) provides`fixture_record_prefix` and `fixture_record_suffix`. These values are propagated to the associated records when calling `to_fixture_record`.
 ```ruby
 user.test_fixture_prefix = :foo
-user.to_test_fixture(:posts)
+user.to_fixture_record(:posts)
 
 # users.yml
 
@@ -158,7 +158,7 @@ end
 FixtureRecord.configure do |config|
   ...
 
-  config.sanitize_pattern /created_at$|updated_at$/, with: :simple_timestamp
+  config.sanitize_column_regex /created_at$|updated_at$/, with: :simple_timestamp
 
   ...
 end
@@ -186,13 +186,13 @@ end
 FixtureRecord.registry.register_sanitizer MyReverseSanitizer, :reverse
 ```
 ### Assiging the Sanitizer to a Pattern
-In the fixture record initializer, use `#sanitize_pattern` to assign the registered sanitizer to a regex pattern. In the following example code, any column that matches `email` would be sent through the reverse sanitizer, this would include `email`, `user_email`, `primary_email`, etc.
+In the fixture record initializer, use `#sanitize_column_regex` to assign the registered sanitizer to a regex pattern. In the following example code, any column that matches `email` would be sent through the reverse sanitizer, this would include `email`, `user_email`, `primary_email`, etc.
 ```ruby
 # fixture_record/initializer.rb
 FixtureRecord.configure do |config|
   ...
 
-  config.sanitize_pattern /email/, with: :reverse
+  config.sanitize_column_regex /email/, with: :reverse
 
   ...
 end
@@ -200,7 +200,7 @@ end
 
 The pattern that is used for comparison is inclusive of the class name as well. So if you need a sanitizer to be scoped to a specific class you can use the class name in the regex pattern. Taking the example above:
 ```ruby
-config.sanitize_pattern /User.email/, with: :reverse
+config.sanitize_column_regex /User.email/, with: :reverse
 ```
 Now columns on other classes that include `email` in their name won't be passed to the sanitizer. Also keep in mind the mechanism being used here is basic regex pattern matching, so `User.primary_email` wouldn't match in this case and would not be sent to the sanitizer.
 

data/lib/fixture_record/association_traversal.rb

@@ -52,7 +52,7 @@ module FixtureRecord
         built_records.each do |record|
           record.fixture_record_prefix = @source_record.fixture_record_prefix
           record.fixture_record_suffix = @source_record.fixture_record_suffix
-          record.to_test_fixture(*@next_associations)
+          record.to_fixture_record(*@next_associations)
         end
       end
 

data/lib/fixture_record/belongs_to_updation.rb

@@ -2,7 +2,7 @@ module FixtureRecord
   module BelongsToUpdation
     extend ActiveSupport::Concern
 
-    def update_belongs_to_test_fixture_associations
+    def update_belongs_to_fixture_record_associations
       self.class.reflect_on_all_associations(:belongs_to).each do |assoc|
         klass_name = assoc.options[:polymorphic] ? send(assoc.foreign_type) : assoc.class_name
         next unless klass_name.nil? || FixtureRecord.cache.contains_class?(klass_name)

data/lib/fixture_record/cache.rb

@@ -24,9 +24,9 @@ module FixtureRecord
 
     def prepare!
       self.values
-        .each(&:filter_attributes_for_test_fixture)
-        .each(&:sanitize_attributes_for_test_fixture)
-        .each(&:update_belongs_to_test_fixture_associations)
+        .each(&:filter_attributes_for_fxiture_record)
+        .each(&:sanitize_attributes_for_fxiture_record)
+        .each(&:update_belongs_to_fixture_record_associations)
     end
   end
 end

data/lib/fixture_record/data.rb

@@ -14,14 +14,18 @@ class FixtureRecord::Data < Hash
   end
 
   def write!
-    FileUtils.mkdir_p(Rails.root.join('test/fixtures'))
+    FileUtils.mkdir_p(FixtureRecord.base_path)
     self.each do |klass, data|
       File.open(fixture_path_for(klass), 'w') { |f| f.write data.to_yaml }
     end
   end
 
   def fixture_path_for(klass)
-    Rails.root.join('test/fixtures', klass.table_name + '.yml')
+    if FixtureRecord.base_path.is_a?(String)
+      [FixtureRecord.base_path, klass.table_name + '.yml'].join('/')
+    else
+      FixtureRecord.base_path.join(klass.table_name + '.yml')
+    end
   end
 
   def merge_record(record)

data/lib/fixture_record/filterable_attributes.rb

@@ -1,6 +1,6 @@
 module FixtureRecord
   module FilterableAttributes
-    def filter_attributes_for_test_fixture
+    def filter_attributes_for_fxiture_record
       self._fixture_record_attributes = FilteredAttributes.new(self).cast
     end
 

data/lib/fixture_record/naming.rb

@@ -11,7 +11,7 @@ module FixtureRecord
     end
 
     def test_fixture_name
-      FixtureRecord.naming.call(self)
+      FixtureRecord.name_handler.call(self)
     end
   end
 end

data/lib/fixture_record/sanitizable.rb

@@ -1,7 +1,7 @@
 module FixtureRecord::Sanitizable
   extend ActiveSupport::Concern
 
-  def sanitize_attributes_for_test_fixture
+  def sanitize_attributes_for_fxiture_record
     _fixture_record_attributes.each do |attr, value|
       registry_key = [self.class.name, attr.to_s].join('.')
       _fixture_record_attributes[attr] = sanitize_value_for_test_fixture(registry_key, value)

data/lib/fixture_record/version.rb

@@ -1,3 +1,3 @@
 module FixtureRecord
-  VERSION = "0.1.2-rc"
+  VERSION = "1.0"
 end

data/lib/fixture_record.rb

@@ -7,7 +7,6 @@ require "fixture_record/association_traversal"
 require "fixture_record/filterable_attributes"
 require "fixture_record/belongs_to_updation"
 require "fixture_record/sanitizable"
-require "fixture_record/configuration"
 
 module FixtureRecord
   extend ActiveSupport::Concern
@@ -15,7 +14,9 @@ module FixtureRecord
     :cache,
     :data
 
-  mattr_accessor :naming, default: FixtureRecord::Naming::Base.new
+  mattr_accessor :name_handler, default: FixtureRecord::Naming::Base.new
+  mattr_accessor :sanitizers, default: []
+  mattr_accessor :base_path, default: -> { Rails.root.join('test/fixtures') }
 
   included do
     attr_accessor :_fixture_record_attributes
@@ -29,7 +30,7 @@ module FixtureRecord
 
   Sanitizer = FixtureRecord::Sanitizable::Base
 
-  def to_test_fixture(*associations)
+  def to_fixture_record(*associations)
     FixtureRecord.lock!(self)
     FixtureRecord.cache[self.test_fixture_name] ||= self
     traverse_fixture_record_associations(*associations)
@@ -41,13 +42,23 @@ module FixtureRecord
 
   class << self
     def configure
-      yield config
+      yield self
     end
 
-    def config
-      @@config ||= Configuration.new
+    def base_path
+      @@base_path.is_a?(String) ? @@base_path : @@base_path.call
     end
 
+    def name_handler=(proc_or_klass)
+      @@name_handler = proc_or_klass.is_a?(Class) ? proc_or_klass.new : proc_or_klass
+    end
+
+    def sanitize_column_regex(col_regex, with:)
+      registry_name_or_klass = with
+      klass = registry_name_or_klass.is_a?(Symbol) ? FixtureRecord.registry[registry_name_or_klass] : registry_name_or_klass
+      klass_instance = klass.is_a?(Class) ? klass.new : klass
+      FixtureRecord.registry.sanitize_pattern col_regex, with: klass_instance
+    end
 
     def lock!(owner)
       return if locked?

data/lib/generators/fixture_record/install/install_generator.rb

@@ -5,17 +5,7 @@ module FixtureRecord::Generators
     source_root File.expand_path("templates", __dir__)
 
     def create_initializer
-      application(nil, env: :development) do
-        <<-TXT
-          # By default, fixture_record will only inject itself in the development environment.
-          # If you want it available in `test` or `production` (or other environments), please add
-          # this require line to those environment ruby files. Alternatively, if you want it to
-          # always be loaded, you can relocate the generated `fixture_record/initializer.rb` to
-          # `app/config/initializers/fixture_record.rb` or require this file in  `config/application.rb`.
-          require Rails.root.join('fixture_record', 'initializer.rb')\n
-        TXT
-      end
-			template "initializer.rb", Rails.root.join("fixture_record/initializer.rb")
+			template "initializer.rb", Rails.root.join("config/initializers/fixture_record.rb")
 		end
   end
 end

data/lib/generators/fixture_record/install/templates/initializer.rb

@@ -1,16 +1,23 @@
-FixtureRecord.configure do |config|
-  # To customize how fixtures are named, provide a class the responds to #call or a Proc.
-  # The naming object will receive the record and should return a String
-  # config.name_records_with = FixtureRecord::Naming::Base
+if Rails.env.development?
+  FixtureRecord.configure do |config|
+    # To customize how fixtures are named, provide a class the responds to #call or a Proc.
+    # The name handler object will receive the record and should return a String
+    # config.name_handler = FixtureRecord::Naming::Base
 
-  # Create and register custom sanitizers to format, sanitiize, obfuscate, etc. the data before it is
-  # turned into a test fixture. Regex patterns are used to determine if a column should be passed to a
-  # sanitizer. The regex pattern that is tested is Classname.column_name - so if a sanitizer needs to be
-  # scoped to a specific class only, simply add the classname to the pattern, for example /User.phone_number/
-  # would sanitize the phone_number field for a User but not the phone_number field for a Customer.
-  # If there are other timestamp columns being used throughout your application, you can added them to this list.
-  config.sanitize_pattern /created_at$|updated_at$/, with: :simple_timestamp
+    # base_path represents the base folder that FixureRecord will search for existing yml files
+    # to merge new fixture data with and it serves as the path for where FixtureRecord will output the
+    # new yml files as needed. To override, provide a String, Pathname object, or Proc/ambda to be evaluated at runtime
+    # config.base_path = -> { Rails.root.join('test/fixtures') }
 
-  # Inject FixtureRecord concern into ActiveRecord
-  ActiveRecord::Base.include(FixtureRecord)
+    # Create and register custom sanitizers to format, sanitiize, obfuscate, etc. the data before it is
+    # turned into a test fixture. Regex patterns are used to determine if a column should be passed to a
+    # sanitizer. The regex pattern that is tested is Classname.column_name - so if a sanitizer needs to be
+    # scoped to a specific class only, simply add the classname to the pattern, for example /User.phone_number/
+    # would sanitize the phone_number field for a User but not the phone_number field for a Customer.
+    # If there are other timestamp columns being used throughout your application, you can added them to this list.
+    config.sanitize_column_regex /created_at$|updated_at$/, with: :simple_timestamp
+
+    # Inject FixtureRecord concern into ActiveRecord
+    ActiveRecord::Base.include(FixtureRecord)
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fixture_record
 version: !ruby/object:Gem::Version
-  version: 0.1.2.pre.rc
+  version: '1.0'
 platform: ruby
 authors:
 - Brad Schrag
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-03-31 00:00:00.000000000 Z
+date: 2024-04-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -39,7 +39,6 @@ files:
 - lib/fixture_record/association_traversal.rb
 - lib/fixture_record/belongs_to_updation.rb
 - lib/fixture_record/cache.rb
-- lib/fixture_record/configuration.rb
 - lib/fixture_record/data.rb
 - lib/fixture_record/filterable_attributes.rb
 - lib/fixture_record/naming.rb

data/lib/fixture_record/configuration.rb

@@ -1,14 +0,0 @@
-module FixtureRecord
-  class Configuration
-    def name_records_with(proc_or_klass)
-      FixtureRecord.naming = proc_or_klass.is_a?(Class) ? proc_or_klass.new : proc_or_klass
-    end
-
-    def sanitize_pattern(pattern, with:)
-      registry_name_or_klass = with
-      klass = registry_name_or_klass.is_a?(Symbol) ? FixtureRecord.registry[registry_name_or_klass] : registry_name_or_klass
-      klass_instance = klass.is_a?(Class) ? klass.new : klass
-      FixtureRecord.registry.sanitize_pattern pattern, with: klass_instance
-    end
-  end
-end