fixture_farm 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 90fbbd430cc9517a11e666fdb080b4289924871a2b73d23229e6293a16adc677
+  data.tar.gz: ff02de63066e6b8b012cb55c6e04785dff300a62b8da6e85542d8d87770462c4
+SHA512:
+  metadata.gz: 7eead7fd8cc32ab9b27b1ce2fb825fa84f8ff3ca23073c13d1737e3f4f3c59fee6d6a5c38124d59e7980c1336ac2c3f7a8f93825240dd88f7714b4abb76b2137
+  data.tar.gz: 253909f06e93222c1badb80dda9d8b06726080dca76356ddb562ac38df18bdc0dd9873211f79e4a3282967db50971b29ffb9f9e2a187e7eb79d9161791eb3516

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2021 artemave
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,82 @@
+# FixtureFarm
+
+This gem lets you do two things:
+
+- record fixtures as you browse.
+- record fixtures for a block of code (e.g. setup part of a test).
+
+Generated fixture that `belongs_to` a record from an existing fixture, will reference that fixture by name.
+
+## Usage
+
+### Record as you browse
+
+To record as you browse in development add this to `ApplicationController`:
+
+```ruby
+include FixtureFarm::ControllerHook if Rails.env.development?
+```
+
+Then start/stop recording using tasks:
+
+```bash
+bundle exec fixture_farm record some_awesome_name_prefix
+bundle exec fixture_farm status
+bundle exec fixture_farm stop
+```
+
+### Record in tests
+
+To record in tests, wrap some code in `record_new_fixtures` block. For example:
+
+```ruby
+
+include FixtureFarm::TestHelper
+
+test 'some stuff does the right thing' do
+  record_new_fixtures('some_stuff') do |stop_recording|
+    user = User.create!(name: 'Bob')
+    post = user.posts.create!(title: 'Stuff')
+
+    stop_recording.call
+
+    assert_difference 'user.published_posts.size' do
+      post.publish!
+    end
+  end
+end
+```
+
+Running this test generates user and post fixtures. Now you can rewrite this test to use them:
+
+```ruby
+test 'some stuff does the right thing' do
+  user = users('some_stuff_user_1')
+
+  assert_difference 'user.published_posts.size' do
+    user.posts.first.publish!
+  end
+end
+```
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'fixture_farm', group: %i[development test]
+```
+
+And then execute:
+
+```bash
+bundle install
+```
+
+Or install it yourself as:
+
+```bash
+gem install fixture_farm
+```
+
+## 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,13 @@
+require "bundler/setup"
+
+require "bundler/gem_tasks"
+
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+task default: :test

data/bin/fixture_farm

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+system(
+  "rails runner #{File.expand_path('fixture_farm.rb', __dir__)} #{ARGV.join(' ')}",
+  exception: true
+)

data/lib/fixture_farm/active_record_extension.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module FixtureFarm
+  module ActiveRecordExtension
+    def fixture_name
+      require 'active_record/fixtures'
+
+      return nil unless fixture_file_path
+
+      fixtures = YAML.load_file(fixture_file_path)
+      fixtures.keys.find do |key|
+        ActiveRecord::FixtureSet.identify(key) == id
+      end
+    end
+
+    def fixture_file_path
+      klass = self.class
+
+      while klass < ActiveRecord::Base
+        path = Rails.root.join('test', 'fixtures', "#{klass.to_s.underscore.pluralize}.yml")
+        return path if File.exist?(path)
+
+        klass = klass.superclass
+      end
+
+      nil
+    end
+  end
+end

data/lib/fixture_farm/controller_hook.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "fixture_farm/fixture_recorder"
+
+module FixtureFarm
+  module ControllerHook
+    extend ActiveSupport::Concern
+
+    included do
+      around_action :record_new_fixtures, if: :record_new_fixtures?
+    end
+
+    private
+
+    def record_new_fixtures(&block)
+      fixture_recorder = FixtureRecorder.resume_recording_session
+
+      fixture_recorder.record_new_fixtures do
+        block.call
+      end
+    ensure
+      fixture_recorder.update_recording_session
+    end
+
+    def record_new_fixtures?
+      FixtureRecorder.recording_session_in_progress?
+    end
+  end
+end

data/lib/fixture_farm/fixture_recorder.rb

@@ -0,0 +1,216 @@
+# frozen_string_literal: true
+
+module FixtureFarm
+  class FixtureRecorder
+    STORE_PATH = Rails.root.join('tmp', 'fixture_farm_store.json')
+
+    def initialize(fixture_name_prefix, new_models = [])
+      @fixture_name_prefix = fixture_name_prefix
+      @new_models = new_models
+      @initial_now = Time.zone.now
+    end
+
+    def self.resume_recording_session
+      start_recording_session! unless recording_session_in_progress?
+
+      recording_session = JSON.load_file(STORE_PATH)
+
+      new_models = recording_session['new_models'].map do |(class_name, id)|
+        class_name.constantize.find(id)
+      end
+
+      new(recording_session['fixture_name_prefix'], new_models)
+    end
+
+    def self.start_recording_session!(fixture_name_prefix)
+      File.write(STORE_PATH, {
+        fixture_name_prefix: fixture_name_prefix,
+        new_models: []
+      }.to_json)
+    end
+
+    def self.stop_recording_session!
+      FileUtils.rm_f(STORE_PATH)
+    end
+
+    def self.recording_session_in_progress?
+      File.exist?(STORE_PATH)
+    end
+
+    def record_new_fixtures
+      stopped = false
+
+      subscriber = ActiveSupport::Notifications.subscribe 'sql.active_record' do |event|
+        payload = event.payload
+
+        next unless payload[:name] =~ /(\w+) Create/
+
+        new_fixture_class_name = Regexp.last_match(1)
+
+        payload[:connection].transaction_manager.current_transaction.records.reject(&:persisted?).reject(&:destroyed?).each do |model_instance|
+          next if new_fixture_class_name != model_instance.class.name
+
+          @new_models << model_instance
+        end
+      end
+
+      yield lambda {
+        ActiveSupport::Notifications.unsubscribe(subscriber)
+        stopped = true
+        reload_models
+        update_fixture_files(named_new_fixtures)
+      }
+
+      unless stopped
+        reload_models
+        update_fixture_files(named_new_fixtures)
+      end
+    ensure
+      ActiveSupport::Notifications.unsubscribe(subscriber)
+    end
+
+    def update_recording_session
+      return unless FixtureRecorder.recording_session_in_progress?
+
+      File.write(STORE_PATH, {
+        fixture_name_prefix: @fixture_name_prefix,
+        new_models: @new_models.map { |model| [model.class.name, model.id] }
+      }.to_json)
+    end
+
+    private
+
+    def reload_models
+      @new_models = @new_models.map do |model_instance|
+        # reload in case model was updated after initial create
+        model_instance.reload
+        # Some records are created and then later removed.
+        # We don't want to turn those into fixtures
+      rescue ActiveRecord::RecordNotFound
+        nil
+      end.compact
+    end
+
+    def named_new_fixtures
+      @new_models.uniq(&:id).each_with_object({}) do |model_instance, named_new_fixtures|
+        new_fixture_name = "#{@fixture_name_prefix}_#{model_instance.class.name.underscore.gsub('/', '_')}_1"
+
+        while named_new_fixtures[new_fixture_name]
+          new_fixture_name = new_fixture_name.sub(/_(\d+)$/, "_#{Regexp.last_match(1).to_i + 1}")
+        end
+
+        named_new_fixtures[new_fixture_name] = model_instance
+      end
+    end
+
+    def update_fixture_files(named_new_fixtures)
+      named_new_fixtures.each do |new_fixture_name, model_instance|
+        attributes = model_instance.attributes
+
+        yaml_attributes = attributes.except('id').compact.map do |k, v|
+          belongs_to_association = model_instance.class.reflect_on_all_associations.filter(&:belongs_to?).find do |a|
+            a.foreign_key.to_s == k
+          end
+
+          if belongs_to_association
+            associated_model_instance = model_instance.public_send(belongs_to_association.name)
+
+            associated_fixture_name = named_new_fixtures.find do |_, fixture_model|
+              fixture_model.id == associated_model_instance.id
+            end&.first || associated_model_instance.fixture_name
+
+            [belongs_to_association.name.to_s, associated_fixture_name]
+          else
+            [k, serialize_attributes(v)]
+          end
+        end.to_h
+
+        fixture_file_path = model_instance.fixture_file_path || Rails.root.join('test', 'fixtures', "#{model_instance.class.table_name}.yml")
+
+        fixtures = File.exist?(fixture_file_path) ? YAML.load_file(fixture_file_path) : {}
+        fixtures[new_fixture_name] = yaml_attributes
+
+        File.open(fixture_file_path, 'w') do |file|
+          yaml = YAML.dump(fixtures).gsub(/\n(?=[^\s])/, "\n\n").delete_prefix("---\n\n")
+          file.write(yaml)
+        end
+      end
+    end
+
+    def serialize_attributes(value)
+      case value
+      when ActiveSupport::TimeWithZone, Date
+        "<%= #{datetime_erb(value)} %>"
+      when ActiveSupport::Duration
+        value.iso8601
+      when BigDecimal
+        value.to_f
+      else
+        value
+      end
+    end
+
+    def round_time(value)
+      if value.to_datetime.minute == 59
+        value += 1.minute
+        value = value.beginning_of_hour
+      elsif value.to_datetime.minute == 1 || value.to_datetime.minute == 0
+        value = value.beginning_of_hour
+      end
+      value
+    end
+
+    def datetime_erb(value)
+      beginning_of_day = value == value.beginning_of_day
+
+      rounded_initial_now = round_time(@initial_now)
+      rounded_now = round_time(Time.zone.now)
+
+      if value.is_a?(Date)
+        rounded_initial_now = rounded_initial_now.to_date
+        rounded_now = rounded_now.to_date
+      elsif beginning_of_day
+        rounded_initial_now = rounded_initial_now.beginning_of_day
+        rounded_now = rounded_now.beginning_of_day
+      end
+
+      time_travel_diff = dt_diff(rounded_initial_now, rounded_now)
+
+      rounded_value = time_travel_diff.inject(value) { |sum, (part, v)| sum + v.public_send(part) }
+      rounded_value = round_time(rounded_value) unless value.is_a?(Date)
+
+      parts = dt_diff(rounded_value, rounded_initial_now)
+
+      formatted_now = if value.is_a?(Date)
+                        'Date.today'
+                      else
+                        beginning_of_day ? 'Time.zone.now.beginning_of_day' : 'Time.zone.now'
+                      end
+
+      ([formatted_now] + parts.delete_if { |_, v| v.zero? }.map do |(part, v)|
+        "#{v.positive? ? '+' : '-'} #{v.abs}.#{part.pluralize(v.abs)}"
+      end).join(' ')
+    end
+
+    def dt_diff(left, right)
+      units = %w[year month week day]
+      units += %w[hour minute] unless left.is_a?(Date)
+
+      units.each_with_object({ value_rest: left }) do |unit, acc|
+        acc[unit] ||= 0
+
+        if left > right
+          while acc[:value_rest] - 1.public_send(unit) >= right
+            acc[unit] += 1
+            acc[:value_rest] -= 1.public_send(unit)
+          end
+        else
+          while acc[:value_rest] + 1.public_send(unit) <= right
+            acc[unit] -= 1
+            acc[:value_rest] += 1.public_send(unit)
+          end
+        end
+      end.except(:value_rest)
+    end
+  end
+end

data/lib/fixture_farm/test_helper.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require "fixture_farm/fixture_recorder"
+
+module FixtureFarm
+  module TestHelper
+    def record_new_fixtures(fixture_name_prefix, &block)
+      FixtureRecorder.new(fixture_name_prefix).record_new_fixtures(&block)
+    end
+  end
+end

data/lib/fixture_farm/version.rb

@@ -0,0 +1,3 @@
+module FixtureFarm
+  VERSION = '0.1.0'
+end

data/lib/fixture_farm.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'fixture_farm/version'
+
+module FixtureFarm
+  autoload :ActiveRecordExtension, 'fixture_farm/active_record_extension'
+  autoload :ControllerHook, 'fixture_farm/controller_hook'
+  autoload :TestHelper, 'fixture_farm/test_helper'
+  autoload :FixtureRecorder, 'fixture_farm/fixture_recorder'
+end
+
+ActiveSupport.on_load(:active_record) do |base|
+  base.include FixtureFarm::ActiveRecordExtension
+end

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification
+name: fixture_farm
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- artemave
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2021-11-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 6.1.4
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.1.4.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 6.1.4
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.1.4.1
+description: 
+email:
+- mr@artem.rocks
+executables:
+- fixture_farm
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- bin/fixture_farm
+- lib/fixture_farm.rb
+- lib/fixture_farm/active_record_extension.rb
+- lib/fixture_farm/controller_hook.rb
+- lib/fixture_farm/fixture_recorder.rb
+- lib/fixture_farm/test_helper.rb
+- lib/fixture_farm/version.rb
+homepage: https://github.com/featurist/fixture_farm
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/featurist/fixture_farm
+  source_code_uri: https://github.com/featurist/fixture_farm.git
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.5.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.6
+signing_key: 
+specification_version: 4
+summary: Generate rails fixutures while browsing
+test_files: []