fixture_record 0.1.1.pre.rc → 0.1.2.pre.rc

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6720df231526a9d9119a2146337d2c029e5c1479eaea6f88b17df9ce8e1222fc
-  data.tar.gz: '0579da7648101dbdf1f3ca02add8ac87a23192fb2ba635ac6749f87e394d062e'
+  metadata.gz: e0b73f48614260bc6e1dc1f0ecebcabe4b5bb44779eb3ba807be3942fd8439fc
+  data.tar.gz: 2af43ba19fd5cde723d3dede76fd21eecd17f92d1ad38693702d14fbd85939fa
 SHA512:
-  metadata.gz: 1de630e483468ae70fb9e41351f5607fee4516ffea36f9008860a801c7a95c2347d608bf2c6d50c559d302eac7eb0deb2d606cd71e4914e8c8728e09d3bb60d1
-  data.tar.gz: 6d21e6b3cd38b97122fdf567df30b9d657df3a7787e481ed79343dd691edfd48882b353f96fb3edc2693b7336b67e5c2448ec75bd324dd61c0453708ad5ea7e4
+  metadata.gz: 630ec0346571b9f9a35f2a1f319106e4041372a97e4da36980ac24038b2bc8a6f19fc64d6274813834a46a817d148cfdb3961cb9be5a9ede11a20dc7ba543b23
+  data.tar.gz: 1c5fa27c4b2bd560bee90fb1461d53a55fc64e380c7df15876b080b17eea315b7dc3290536b3217c758a6929477c2194766e7bb09d363607414f490c3f766d49

data/README.md

@@ -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_pattern /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_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.
+```ruby
+# fixture_record/initializer.rb
+FixtureRecord.configure do |config|
+  ...
+
+  config.sanitize_pattern /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_pattern /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,8 +39,13 @@ 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?
 
@@ -48,6 +56,17 @@ module FixtureRecord
         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/configuration.rb

@@ -0,0 +1,14 @@
+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

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.naming.call(self)
     end
   end
 end

data/lib/fixture_record/sanitizable.rb

@@ -1,9 +1,6 @@
 module FixtureRecord::Sanitizable
   extend ActiveSupport::Concern
 
-  class_methods do
-  end
-
   def sanitize_attributes_for_test_fixture
     _fixture_record_attributes.each do |attr, value|
       registry_key = [self.class.name, attr.to_s].join('.')
@@ -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 = "0.1.2-rc"
 end

data/lib/fixture_record.rb

@@ -7,10 +7,15 @@ 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
-  mattr_accessor :_locked_by, :cache, :data
+  mattr_accessor :_locked_by,
+    :cache,
+    :data
+
+  mattr_accessor :naming, default: FixtureRecord::Naming::Base.new
 
   included do
     attr_accessor :_fixture_record_attributes
@@ -33,7 +38,17 @@ module FixtureRecord
     FixtureRecord.release!(self)
   end
 
+
   class << self
+    def configure
+      yield config
+    end
+
+    def config
+      @@config ||= Configuration.new
+    end
+
+
     def lock!(owner)
       return if locked?
 

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

@@ -4,12 +4,18 @@ 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")
+      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")
 		end
   end
 end

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

@@ -1,9 +1,16 @@
-# 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.
+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?
-  # Inject FixtureRecord after active_record loads
-  ActiveSupport.on_load(:active_record) do
-    ActiveRecord::Base.include(FixtureRecord)
-  end
+  # 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
+
+  # Inject FixtureRecord concern into ActiveRecord
+  ActiveRecord::Base.include(FixtureRecord)
 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: 0.1.2.pre.rc
 platform: ruby
 authors:
 - Brad Schrag
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-03-28 00:00:00.000000000 Z
+date: 2024-03-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -39,6 +39,7 @@ 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