fixture_record 0.1.1.pre.rc → 1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6720df231526a9d9119a2146337d2c029e5c1479eaea6f88b17df9ce8e1222fc
-  data.tar.gz: '0579da7648101dbdf1f3ca02add8ac87a23192fb2ba635ac6749f87e394d062e'
+  metadata.gz: 725ff327350c904ec886ba1833e976a798e47d564aac8539dec6f2614d86f298
+  data.tar.gz: d820511bb21ee20a76c5e12109030e56bde60e3eab69c100248285d59dbb9047
 SHA512:
-  metadata.gz: 1de630e483468ae70fb9e41351f5607fee4516ffea36f9008860a801c7a95c2347d608bf2c6d50c559d302eac7eb0deb2d606cd71e4914e8c8728e09d3bb60d1
-  data.tar.gz: 6d21e6b3cd38b97122fdf567df30b9d657df3a7787e481ed79343dd691edfd48882b353f96fb3edc2693b7336b67e5c2448ec75bd324dd61c0453708ad5ea7e4
+  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
 
@@ -124,6 +124,86 @@ foo_post_49:
   ...
 ```
 
+## Data Sanitizing and Obfuscation
+`FixtureRecord` supports mutating data before writing the data. By default, `FixtureRecord` has a built in sanitizer that is used for `created_at` and `updated_at` fields. The reason for the `simple_timestamp` is that Rails will turn a timestamp into a complex object when calling `to_yaml`.
+```ruby
+user.attributes.to_yaml
+# =>
+id: ...
+created_at: !ruby/object:ActiveSupport::TimeWithZone
+  utc: 2024-03-17 23:11:31.329037000 Z
+  zone: &1 !ruby/object:ActiveSupport::TimeZone
+    name: Etc/UTC
+  time: 2024-03-17 23:11:31.329037000 Z
+updated_at: !ruby/object:ActiveSupport::TimeWithZone
+  utc: 2024-03-17 23:11:31.329037000 Z
+  zone: *1
+  time: 2024-03-17 23:11:31.329037000 Z
+```
+This type of timestamp structure isn't needed and can simply clutter up a fixture file. So instead, `FixtureRecord` comes with a sanitizer to clean this up.
+```ruby
+# lib/fixture_record/sanitizers/simple_timestamp
+module FixtureRecord
+  module Sanitizers
+    class SimpleTimestamp < FixtureRecord::Sanitizer
+      def cast(value)
+        value.to_s
+      end
+    end
+    FixtureRecord.registry.register_sanitizer(FixtureRecord::Sanitizers::SimpleTimestamp, as: :simple_timestamp)
+  end
+end
+
+# fixture_record/initializer.rb (created using the install script)
+FixtureRecord.configure do |config|
+  ...
+
+  config.sanitize_column_regex /created_at$|updated_at$/, with: :simple_timestamp
+
+  ...
+end
+```
+
+In this case, any column the regex pattern of 'created_at' or 'updated_at' will have its value passed to the registered sanitizer class.
+
+### Creating a Custom Sanitizer
+Step one, create the custom class. Inheriting from `FixtureRecord::Sanitizer` is not a requirement currently, but there might be some nice-to-have features as part of that class in the future. At minimum, your custom class needs to have at minimum a `#cast` instance method that will receive the value that is to be sanitized and returns the newly converted value. Currently, `#cast` will be called whether the value is `nil` or not, so be sure your method can handle the `nil` scenario.
+```ruby
+class MyReverseSanitizer < FixtureRecord::Sanitizer
+  def cast(value)
+    value&.reverse
+  end
+end
+```
+
+### Registering the Sanitizer
+In your custom class, or in the initializer, register the new sanitizer.
+```ruby
+class MyReverseSanitizer < FixtureRecord::Sanitizer
+  ...
+end
+
+FixtureRecord.registry.register_sanitizer MyReverseSanitizer, :reverse
+```
+### Assiging the Sanitizer to a Pattern
+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_column_regex /email/, with: :reverse
+
+  ...
+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_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.
+
 ## Installation
 `FixtureRecord` is only needed as a development dependency.
 ```ruby

data/lib/fixture_record/association_traversal.rb

@@ -2,7 +2,10 @@ module FixtureRecord
   module AssociationTraversal
     class UnrecognizedAssociationError < StandardError; end
 
+    attr_accessor :_traversed_fixture_record_associations
+
     def traverse_fixture_record_associations(*associations)
+      self._traversed_fixture_record_associations = []
       associations.each do |association|
         Builder.new(self, association).build
       end
@@ -36,18 +39,34 @@ module FixtureRecord
       def build
         raise UnrecognizedAssociationError.new(
           "#{@symbol} is not a recognized association or method on #{@source_record.class}. Is it misspelled?"
-        ) unless @source_record.respond_to?(@symbol)
+        ) unless klass_association.present?
+
+        if through_assoc_option && @source_record._traversed_fixture_record_associations.exclude?(through_assoc_option)
+          infill_through
+        end
 
+        @source_record._traversed_fixture_record_associations << @symbol
         built_records = Array.wrap(@source_record.send(@symbol)).compact_blank
         return unless built_records.present?
 
         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
 
+      def infill_through
+        SymbolBuilder.new(@source_record, through_assoc_option).build
+      end
+
+      def through_assoc_option
+        klass_association.options[:through]
+      end
+
+      def klass_association
+        @source_record.class.reflect_on_association(@symbol)
+      end
     end
 
     class HashBuilder

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

@@ -3,8 +3,15 @@ module FixtureRecord
     attr_accessor :fixture_record_prefix
     attr_accessor :fixture_record_suffix
 
+    class Base
+      def call(record)
+
+        [record.fixture_record_prefix, record.class.model_name.param_key, record.id || 'new', record.fixture_record_suffix].compact_blank.join('_')
+      end
+    end
+
     def test_fixture_name
-      [fixture_record_prefix, self.class.model_name.param_key, (self.id || 'new'), fixture_record_suffix].compact_blank.join '_'
+      FixtureRecord.name_handler.call(self)
     end
   end
 end

data/lib/fixture_record/sanitizable.rb

@@ -1,10 +1,7 @@
 module FixtureRecord::Sanitizable
   extend ActiveSupport::Concern
 
-  class_methods do
-  end
-
-  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)
@@ -24,24 +21,27 @@ module FixtureRecord::Sanitizable
   end
 
   class Registry
-    @_fixture_record_sanitizer_pattern_registry = {}
+    @_fixture_record_sanitizer_pattern_registry = []
     @_fixture_record_sanitizer_name_registry = {}
 
-    def self.register_sanitizer(klass, *patterns, as: nil)
-      if as
-        @_fixture_record_sanitizer_name_registry[as.to_sym] = klass.new
-      end
-      patterns.each do |pattern|
-        @_fixture_record_sanitizer_pattern_registry[pattern] = klass.new
-      end
+    def self.[](...)
+      @_fixture_record_sanitizer_name_registry.send(:[], ...)
+    end
+
+    def self.deregister(klass_or_symbol)
+      @_fixture_record_sanitizer_pattern_registry.delete_if { |pattern, with| with == klass_or_symbol }
+    end
+
+    def self.sanitize_pattern(pattern, with:)
+      @_fixture_record_sanitizer_pattern_registry << [pattern, with]
+    end
+
+    def self.register_sanitizer(klass, as: nil)
+      @_fixture_record_sanitizer_name_registry[as.to_sym] = klass.new
     end
 
     def self.fetch(to_be_matched)
-      if @_fixture_record_sanitizer_name_registry.key?(to_be_matched)
-        @_fixture_record_sanitizer_name_registry[to_be_matched]
-      else
-        @_fixture_record_sanitizer_pattern_registry.select { |pattern, value| to_be_matched.match(pattern) }.values
-      end
+      @_fixture_record_sanitizer_pattern_registry.select { |pattern, value| to_be_matched.match(pattern) }.map(&:last)
     end
   end
 end

data/lib/fixture_record/sanitizers/simple_timestamp.rb

@@ -5,7 +5,6 @@ module FixtureRecord
         value.to_s
       end
     end
-    FixtureRecord.registry.register_sanitizer(FixtureRecord::Sanitizers::SimpleTimestamp, /created_at$|updated_at$/, as: :simple_timestamp)
+    FixtureRecord.registry.register_sanitizer(FixtureRecord::Sanitizers::SimpleTimestamp, as: :simple_timestamp)
   end
 end
-

data/lib/fixture_record/version.rb

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

data/lib/fixture_record.rb

@@ -10,7 +10,13 @@ require "fixture_record/sanitizable"
 
 module FixtureRecord
   extend ActiveSupport::Concern
-  mattr_accessor :_locked_by, :cache, :data
+  mattr_accessor :_locked_by,
+    :cache,
+    :data
+
+  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
@@ -24,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)
@@ -33,7 +39,27 @@ module FixtureRecord
     FixtureRecord.release!(self)
   end
 
+
   class << self
+    def configure
+      yield self
+    end
+
+    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

@@ -4,10 +4,6 @@ module FixtureRecord::Generators
 	class InstallGenerator < ::Rails::Generators::Base
     source_root File.expand_path("templates", __dir__)
 
-    def create_fixture_record_schema
-      # TODO - implement the generator
-    end
-
     def create_initializer
 			template "initializer.rb", Rails.root.join("config/initializers/fixture_record.rb")
 		end

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

@@ -1,9 +1,23 @@
-# FixtureRecord is currently only intended to be loaded in a development environment.
-# Change this conditional at your own risk if you want it to load in production.
-
 if Rails.env.development?
-  # Inject FixtureRecord after active_record loads
-  ActiveSupport.on_load(:active_record) do
+  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
+
+    # 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') }
+
+    # 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.1.pre.rc
+  version: '1.0'
 platform: ruby
 authors:
 - Brad Schrag
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-03-28 00:00:00.000000000 Z
+date: 2024-04-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails