fixtury 0.1.0.alpha

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 73b1b15d6ac9941d265b535f8510cc2896eb4c3fc711af20339b045228e8a888
+  data.tar.gz: ca6171cdfc7c721a88dc6e4055db600e10897894295b40022e45e7a55c5c5497
+SHA512:
+  metadata.gz: d892685cc0b8a4f54c09c188d1afc0dcc8928008f072c76bf18f0fed7ace0c49d194070d61b65dc4653c528b321f08e4ba3adb59cd2d33a192b4e3f984c09776
+  data.tar.gz: cceeab65fe5c416067a7be5ae8fd3c9dc65d73fcf5c812ffc89ba695d60fcae5790414baeea1e43d9c098279e8dddc8a87eede66f275eeb02bfaf11fb1c447f3

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+.byebug_history
+*.gem

data/.ruby-version

@@ -0,0 +1 @@
+2.5.1

data/.travis.yml

@@ -0,0 +1,7 @@
+---
+sudo: false
+language: ruby
+cache: bundler
+rvm:
+  - 2.3.7
+before_install: gem install bundler -v 2.0.2

data/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in fixtury.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,64 @@
+PATH
+  remote: .
+  specs:
+    fixtury (0.1.0.alpha)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (6.0.1)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 0.7, < 2)
+      minitest (~> 5.1)
+      tzinfo (~> 1.1)
+      zeitwerk (~> 2.2)
+    ansi (1.5.0)
+    autotest (5.0.0)
+      minitest-autotest (~> 1.0)
+    builder (3.2.3)
+    byebug (11.0.1)
+    concurrent-ruby (1.1.5)
+    globalid (0.4.2)
+      activesupport (>= 4.2.0)
+    i18n (1.7.0)
+      concurrent-ruby (~> 1.0)
+    metaclass (0.0.4)
+    minitest (5.13.0)
+    minitest-autotest (1.1.1)
+      minitest-server (~> 1.0)
+      path_expander (~> 1.0)
+    minitest-reporters (1.4.2)
+      ansi
+      builder
+      minitest (>= 5.0)
+      ruby-progressbar
+    minitest-server (1.0.5)
+      minitest (~> 5.0)
+    mocha (1.8.0)
+      metaclass (~> 0.0.1)
+    path_expander (1.1.0)
+    rake (10.5.0)
+    ruby-progressbar (1.10.1)
+    sqlite (1.0.2)
+    thread_safe (0.3.6)
+    tzinfo (1.2.5)
+      thread_safe (~> 0.1)
+    zeitwerk (2.2.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  autotest
+  bundler (~> 2.0)
+  byebug
+  fixtury!
+  globalid
+  minitest (~> 5.0)
+  minitest-reporters
+  mocha
+  rake (~> 10.0)
+  sqlite
+
+BUNDLED WITH
+   2.0.2

data/README.md

@@ -0,0 +1,23 @@
+# Fixtury
+
+The goal of this library is to provide an interface for accessing fixture data on-demand rather than having to manage all resources up front. By centralizing and wrapping the definitions of data generation, we can preload and optimize how we load data, yet allow deferred behaviors when desired.
+
+For example, if a developer is running a test locally, there's no reason to build all fixtures for your suite.
+
+```
+class MyTest < ::Test
+
+  fixtury "users.fresh"
+  let(:user) { fixtury("users.fresh") }
+
+  def test_whatever
+    assert_eq "Doug", user.first_name
+  end
+
+end
+
+```
+
+Loading this file would ensure `users.fresh` is loaded into the fixture set before the suite is run. In the context of ActiveSupport::TestCase, the Fixtury::Hooks file will ensure the database records are present prior to your suite running. Setting `use_transactional_fixtures` ensures all records are rolled back prior to running another test.
+
+In a CI environment, we'd likely want to preload all fixtures. This can be done by requiring all the test files, then telling the fixtury store to load all definitions.

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "fixtury"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/fixtury.gemspec

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+lib = File.expand_path("lib", __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "fixtury/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "fixtury"
+  spec.version       = Fixtury::VERSION
+  spec.authors       = ["Mike Nelson"]
+  spec.email         = ["mike@guideline.com"]
+
+  spec.summary       = "Treat fixtures like factories and factories like fixtures"
+  spec.homepage      = "https://github.com/guideline-tech/fixtury"
+
+  spec.metadata["allowed_push_host"] = "https://rubygems.org"
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata["changelog_uri"] = spec.homepage
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "autotest"
+  spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "byebug"
+  spec.add_development_dependency "globalid"
+  spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_development_dependency "minitest-reporters"
+  spec.add_development_dependency "mocha"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "sqlite"
+end

data/lib/fixtury.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+require "active_support/core_ext/module/attribute_accessors"
+require "active_support/core_ext/module/delegation"
+require "fixtury/version"
+require "fixtury/schema"
+require "fixtury/locator"
+require "fixtury/store"
+require "fixtury/execution_context"
+
+module Fixtury
+
+  def self.define(&block)
+    schema.define(&block)
+    schema
+  end
+
+  def self.schema
+    @top_level_schema ||= ::Fixtury::Schema.new(parent: nil, name: "")
+  end
+
+end
+
+require "fixtury/railtie" if defined?(Rails)

data/lib/fixtury/definition.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Fixtury
+  class Definition
+
+    attr_reader :name
+    attr_reader :schema
+
+    attr_reader :callable
+    attr_reader :enhancements
+
+    def initialize(schema: nil, name:, &block)
+      @name = name
+      @schema = schema
+      @callable = block
+      @enhancements = []
+    end
+
+    def enhance(&block)
+      @enhancements << block
+    end
+
+    def enhanced?
+      @enhancements.any?
+    end
+
+    def call(store: nil, execution_context: nil)
+      maybe_set_store_context(store: store) do
+        value = run_callable(store: store, callable: callable, execution_context: execution_context, value: nil)
+        enhancements.each do |e|
+          value = run_callable(store: store, callable: e, execution_context: execution_context, value: value)
+        end
+        value
+      end
+    end
+
+    protected
+
+    def maybe_set_store_context(store:)
+      return yield unless store
+
+      store.with_relative_schema(schema) do
+        yield
+      end
+    end
+
+    def run_callable(store:, callable:, execution_context:, value:)
+      execution_context ||= self
+
+      args = []
+      args << value unless value.nil?
+      if callable.arity > args.length
+        raise ArgumentError, "A store store must be provided if the definition expects it." unless store
+
+        args << store
+      end
+
+      if args.length.positive?
+        execution_context.instance_exec(*args, &callable)
+      else
+        execution_context.instance_eval(&callable)
+      end
+    end
+
+  end
+end

data/lib/fixtury/errors/already_defined_error.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Fixtury
+  module Errors
+    class AlreadyDefinedError < ::StandardError
+
+      def initialize(name)
+        super("An element identified by `#{name}` already exists.")
+      end
+
+    end
+  end
+end

data/lib/fixtury/errors/circular_dependency_error.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Fixtury
+  module Errors
+    class CircularDependencyError < ::StandardError
+
+      def initialize(name)
+        super("One of the depdencies of #{name} is dependent on #{name}.")
+      end
+
+    end
+  end
+end

data/lib/fixtury/errors/fixture_not_defined_error.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Fixtury
+  module Errors
+    class FixtureNotDefinedError < ::StandardError
+
+      def initialize(name)
+        super("A fixture identified by `#{name}` does not exist.")
+      end
+
+    end
+  end
+end

data/lib/fixtury/errors/schema_frozen_error.rb

@@ -0,0 +1,11 @@
+module Fixtury
+  module Errors
+    class SchemaFrozenError < ::StandardError
+
+      def initialize
+        super("Schema is frozen. New namespaces, definitions, and enhancements are not allowed.")
+      end
+
+    end
+  end
+end

data/lib/fixtury/errors/unrecognizable_locator_error.rb

@@ -0,0 +1,11 @@
+module Fixtury
+  module Errors
+    class UnrecognizableLocatorError < ::StandardError
+
+      def initialize(action, thing)
+        super("Locator did not reognize #{thing} during #{action}")
+      end
+
+    end
+  end
+end

data/lib/fixtury/execution_context.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# a class made available so helper methods can be provided within the fixture dsl
+module Fixtury
+  class ExecutionContext
+
+  end
+end

data/lib/fixtury/hooks.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "fixtury/store"
+
+module Fixtury
+  module Hooks
+
+    extend ::ActiveSupport::Concern
+
+    included do
+      class_attribute :fixtury_dependencies
+      self.fixtury_dependencies = Set.new
+    end
+
+    module ClassMethods
+
+      def fixtury(*names)
+        self.fixtury_dependencies += names.flatten.compact.map(&:to_s)
+      end
+
+    end
+
+    def fixtury(name)
+      raise ArgumentError unless self.fixtury_dependencies.include?(name.to_s)
+
+      ::Fixtury::Store.instance.get(name)
+    end
+
+    def fixtury_loaded?(name)
+      ::Fixtury::Store.instance.loaded?(name)
+    end
+
+    def fixtury_database_connections
+      ActiveRecord::Base.connection_handler.connection_pool_list.map(&:connection)
+    end
+
+    # piggybacking activerecord fixture setup for now.
+    def setup_fixtures(*args)
+      if fixtury_dependencies.any?
+        setup_fixtury_fixtures
+      else
+        super
+      end
+    end
+
+    # piggybacking activerecord fixture setup for now.
+    def teardown_fixtures(*args)
+      if fixtury_dependencies.any?
+        teardown_fixtury_fixtures
+      else
+        super
+      end
+    end
+
+    def setup_fixtury_fixtures
+      return unless use_transactional_fixtures
+
+      clear_expired_fixtury_fixtures!
+      load_all_fixtury_fixtures!
+
+      fixtury_database_connections.each do |conn|
+        conn.begin_transaction joinable: false
+      end
+    end
+
+    def teardown_fixtury_fixtures
+      return unless use_transactional_fixtures
+
+      fixtury_database_connections.each(&:rollback_transaction)
+    end
+
+    def clear_expired_fixtury_fixtures!
+      ::Fixtury::Store.instance.clear_expired_references!
+    end
+
+    def load_all_fixtury_fixtures!
+      fixtury_dependencies.each do |name|
+        fixtury(name) unless fixtury_loaded?(name)
+      end
+    end
+
+  end
+end

data/lib/fixtury/locator.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Fixtury
+  class Locator
+
+    class << self
+
+      attr_accessor :instance
+
+      def instance
+        @instance ||= begin
+          require "fixtury/locator_backend/memory"
+          ::Fixtury::Locator.new(
+            backend: ::Fixtury::LocatorBackend::Memory.new
+          )
+        end
+      end
+
+    end
+
+    attr_reader :backend
+
+    def initialize(backend:)
+      @backend = backend
+    end
+
+    def load(ref)
+      raise ArgumentError, "Unable to load a nil ref" if ref.nil?
+
+      backend.load(ref)
+    end
+
+    def dump(value)
+      raise ArgumentError, "Unable to dump a nil value" if value.nil?
+
+      ref = backend.dump(value)
+      raise ArgumentError, "The value resulted in a nil ref" if ref.nil?
+
+      ref
+    end
+
+  end
+end

data/lib/fixtury/locator_backend/common.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "fixtury/errors/unrecognizable_locator_error"
+
+module Fixtury
+  module LocatorBackend
+    module Common
+
+      def recognized_reference?(_ref)
+        raise NotImplementedError
+      end
+
+      def recognized_value?(_value)
+        raise NotImplementedError
+      end
+
+      def load_recognized_reference(_ref)
+        raise NotImplementedError
+      end
+
+      def dump_recognized_value(_value)
+        raise NotImplementedError
+      end
+
+      def load(ref)
+        return load_recognized_reference(ref) if recognized_reference?(ref)
+
+        case ref
+        when Array
+          ref.map { |subref| self.load(subref) }
+        when Hash
+          ref.each_with_object({}) do |(k, subref), h|
+            h[k] = self.load(subref)
+          end
+        else
+          raise ::Fixtury::Errors::UnrecognizableLocatorError.new(:load, ref)
+        end
+      end
+
+      def dump(value)
+        return dump_recognized_value(value) if recognized_value?(value)
+
+        case value
+        when Array
+          value.map { |subvalue| dump(subvalue) }
+        when Hash
+          ref.each_with_object({}) do |(k, subvalue), h|
+            h[k] = dump(subvalue)
+          end
+        else
+          raise ::Fixtury::Errors::UnrecognizableLocatorError.new(:dump, value)
+        end
+      end
+
+    end
+  end
+end

data/lib/fixtury/locator_backend/globalid.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative "./common"
+require "globalid"
+
+module Fixtury
+  module LocatorBackend
+    class GlobalID
+
+      include ::Fixtury::LocatorBackend::Common
+
+      MATCHER = %r{^gid://}.freeze
+
+      def recognized_reference?(ref)
+        ref.is_a?(String) && MATCHER.match?(ref)
+      end
+
+      def recognized_value?(val)
+        val.respond_to?(:to_global_id)
+      end
+
+      def load_recognized_reference(ref)
+        ::GlobalID::Locator.locate ref
+      end
+
+      def dump_recognized_value(value)
+        value.to_global_id.to_s
+      end
+
+    end
+  end
+end

data/lib/fixtury/locator_backend/memory.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative "./common"
+
+module Fixtury
+  module LocatorBackend
+    class Memory
+
+      include ::Fixtury::LocatorBackend::Common
+
+      MATCHER = /^fixtury-oid-(?<object_id>[\d]+)$/.freeze
+
+      def recognized_reference?(ref)
+        ref.is_a?(String) && MATCHER.match?(ref)
+      end
+
+      def recognized_value?(_val)
+        true
+      end
+
+      def load_recognized_reference(ref)
+        match = MATCHER.match(ref)
+        return nil unless match
+
+        ::ObjectSpace._id2ref(match[:object_id].to_i)
+      rescue RangeError
+        nil
+      end
+
+      def dump_recognized_value(value)
+        "fixtury-oid-#{value.object_id}"
+      end
+
+    end
+  end
+end

data/lib/fixtury/path.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Fixtury
+  class Path
+
+    def initialize(namespace:, path:)
+      @namespace = namespace.to_s
+      @path = path.to_s
+      @full_path = (
+        @path.start_with?("/") ?
+        @path :
+        File.expand_path(::File.join(@namespace, @path), "/")
+      )
+      @segments = @full_path.split("/")
+    end
+
+    def top_level_namespace
+      return "" if @segments.size == 1
+
+      @segments.first
+    end
+
+    def relative?
+      @path.start_with?(".")
+    end
+
+    def possible_absolute_paths
+      @possible_absolute_paths ||= begin
+        out = [@full_path]
+        out << @path unless relative?
+        out
+      end
+    end
+
+  end
+end

data/lib/fixtury/railtie.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Fixtury
+  class Railtie < ::Rails::Railtie
+
+    rake_tasks do
+      load "fixtury/tasks.rake"
+    end
+
+  end
+end

data/lib/fixtury/reference.rb

@@ -0,0 +1,13 @@
+module Fixtury
+  class Reference
+
+    attr_reader :name, :value, :created_at
+
+    def initialize(name, value)
+      @name = name
+      @value = value
+      @created_at = Time.now.to_i
+    end
+
+  end
+end

data/lib/fixtury/schema.rb

@@ -0,0 +1,215 @@
+# frozen_string_literal: true
+
+require "fixtury/definition"
+require "fixtury/path"
+require "fixtury/errors/already_defined_error"
+require "fixtury/errors/fixture_not_defined_error"
+require "fixtury/errors/schema_frozen_error"
+
+module Fixtury
+  class Schema
+
+    attr_reader :definitions, :children, :name, :parent, :relative_name
+
+    def initialize(parent:, name:)
+      @name = name
+      @parent = parent
+      @relative_name = @name.split("/").last
+      @frozen = false
+      reset!
+    end
+
+    def reset!
+      @children = {}
+      @definitions = {}
+    end
+
+    def freeze!
+      @frozen = true
+    end
+
+    def frozen?
+      !!@frozen
+    end
+
+    def top_level_schema
+      top_level_schema? ? self : parent.top_level_schema
+    end
+
+    def top_level_schema?
+      parent.nil?
+    end
+
+    def define(&block)
+      ensure_not_frozen!
+      instance_eval(&block)
+      self
+    end
+
+    # helpful for inspection
+    def structure(indent = "")
+      out = []
+      out << "#{indent}ns:#{relative_name}"
+      definitions.keys.sort.each do |key|
+        out << "#{indent}  defn:#{key}"
+      end
+
+      children.keys.sort.each do |key|
+        child = children[key]
+        out << child.structure("#{indent}  ")
+      end
+
+      out.join("\n")
+    end
+
+    def namespace(name, &block)
+      ensure_not_frozen!
+      ensure_no_conflict!(name: name, definitions: true, namespaces: false)
+
+      child = find_or_create_child_schema(name: name)
+      child.instance_eval(&block)
+      child
+    end
+
+    def fixture(name, &block)
+      ensure_not_frozen!
+      ensure_no_conflict!(name: name, definitions: true, namespaces: true)
+      create_child_definition(name: name, &block)
+    end
+
+    def enhance(name, &block)
+      ensure_not_frozen!
+      definition = get_definition!(name)
+      definition.enhance(&block)
+      definition
+    end
+
+    def merge(other_ns)
+      ensure_not_frozen!
+      other_ns.definitions.each_pair do |name, dfn|
+        fixture(name, &dfn.callable)
+        dfn.enhancements.each do |e|
+          enhance(name, &e)
+        end
+      end
+
+      other_ns.children.each_pair do |name, other_ns_child|
+        namespace(name) do
+          merge(other_ns_child)
+        end
+      end
+
+      self
+    end
+
+    def get_definition!(name)
+      dfn = get_definition(name)
+      raise ::Fixtury::Errors::FixtureNotDefinedError, name unless dfn
+
+      dfn
+    end
+
+    def get_definition(name)
+      path = ::Fixtury::Path.new(namespace: self.name, path: name)
+      top_level = top_level_schema
+
+      dfn = nil
+      path.possible_absolute_paths.each do |abs_path|
+        *namespaces, definition_name = abs_path.split("/")
+
+        namespaces.shift if namespaces.first == top_level.name
+        target = top_level
+
+        namespaces.each do |ns|
+          next if ns.empty?
+
+          target = target.children[ns]
+          break unless target
+        end
+
+        dfn = target.definitions[definition_name] if target
+        return dfn if dfn
+      end
+
+      nil
+    end
+
+    def get_namespace(name)
+      path = ::Fixtury::Path.new(namespace: self.name, path: name)
+      top_level = top_level_schema
+
+      path.possible_absolute_paths.each do |abs_path|
+        *namespaces, _definition_name = abs_path.split("/")
+
+        namespaces.shift if namespaces.first == top_level.name
+        target = top_level
+
+        namespaces.each do |ns|
+          next if ns.empty?
+
+          target = target.children[ns]
+          break unless target
+        end
+
+        return target if target
+      end
+
+      nil
+    end
+
+    protected
+
+    def find_child_schema(name:)
+      children[name.to_s]
+    end
+
+    def find_or_create_child_schema(name:)
+      name = name.to_s
+      child = find_child_schema(name: name)
+      child ||= begin
+        children[name] = begin
+          child_name = build_child_name(name: name)
+          self.class.new(name: child_name, parent: self)
+        end
+      end
+    end
+
+    def find_child_definition(name:)
+      definitions[name.to_s]
+    end
+
+    def create_child_definition(name:, &block)
+      child_name = build_child_name(name: name)
+      definition = ::Fixtury::Definition.new(name: child_name, schema: self, &block)
+      definitions[name.to_s] = definition
+    end
+
+    def build_child_name(name:)
+      name = name&.to_s
+      raise ArgumentError, "`name` must be provided" if name.nil?
+      raise ArgumentError, "#{name} is invalid. `name` must contain only a-z, A-Z, 0-9, and _." unless name.match(/^[a-zA-Z_0-9]+$/)
+
+      arr = ["", self.name, name]
+      arr.join("/").gsub(%r{/{2,}}, "/")
+    end
+
+    def ensure_no_conflict!(name:, namespaces:, definitions:)
+      if definitions
+        definition = find_child_definition(name: name)
+        raise ::Fixtury::Errors::AlreadyDefinedError, definition.name if definition
+      end
+
+      if namespaces
+        ns = find_child_schema(name: name)
+        raise ::Fixtury::Errors::AlreadyDefinedError, ns.name if ns
+      end
+    end
+
+    def ensure_not_frozen!
+      return unless frozen?
+
+      raise ::Fixtury::Errors::SchemaFrozenError
+    end
+
+  end
+end

data/lib/fixtury/store.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+require "singleton"
+require "yaml"
+require "fixtury/locator"
+require "fixtury/errors/circular_dependency_error"
+require "fixtury/execution_context"
+require "fixtury/reference"
+
+module Fixtury
+  class Store
+
+    cattr_accessor :instance
+
+    HOLDER = "__BUILDING_FIXTURE__"
+
+    attr_reader :filepath, :references, :ttl, :auto_refresh_expired
+    attr_reader :schema, :locator
+    attr_reader :verbose
+    attr_reader :execution_context
+
+    def initialize(
+      filepath: nil,
+      locator: ::Fixtury::Locator.instance,
+      verbose: false,
+      ttl: nil,
+      schema: nil,
+      auto_refresh_expired: false
+    )
+      @schema = schema || ::Fixtury.schema
+      @verbose = verbose
+      @locator = locator
+      @filepath = filepath
+      @references = @filepath && ::File.file?(@filepath) ? ::YAML.load_file(@filepath) : {}
+      @execution_context = ::Fixtury::ExecutionContext.new
+      @ttl = ttl ? ttl.to_i : ttl
+      @auto_refresh_expired = !!auto_refresh_expired
+      self.class.instance ||= self
+    end
+
+    def dump_to_file
+      return unless filepath
+
+      ::File.open(filepath, "wb") { |io| io.write(references.to_yaml) }
+    end
+
+    def clear_expired_references!
+      return unless ttl
+
+      references.delete_if do |name, ref|
+        is_expired = ref_expired?(ref)
+        log { "expiring #{name}" } if is_expired
+        is_expired
+      end
+    end
+
+    def load_all(schema = self.schema)
+      schema.definitions.each_pair do |_key, dfn|
+        get(dfn.name)
+      end
+
+      schema.schemas.each_pair do |_key, ns|
+        load_all(ns)
+      end
+    end
+
+    def clear_cache!(pattern: nil)
+      pattern ||= "*"
+      pattern = "/" + pattern unless pattern.start_with?("/")
+      glob = pattern.ends_with?("*")
+      pattern = pattern[0...-1] if glob
+      references.delete_if do |key, _value|
+        hit = glob ? key.start_with?(pattern) : key == pattern
+        log(true) { "clearing #{key}" } if hit
+        hit
+      end
+      dump_to_file
+    end
+
+    def with_relative_schema(schema)
+      prior = @schema
+      @schema = schema
+      yield
+    ensure
+      @schema = prior
+    end
+
+    def loaded?(name)
+      dfn = schema.get_definition!(name)
+      full_name = dfn.name
+      ref = references[full_name]
+      result = ref && ref != HOLDER
+      log { result ? "hit #{full_name}" : "miss #{full_name}" }
+      result
+    end
+
+    def get(name)
+      dfn = schema.get_definition!(name)
+      full_name = dfn.name
+      ref = references[full_name]
+
+      if ref == HOLDER
+        raise ::Fixtury::Errors::CircularDependencyError, full_name
+      end
+
+      if ref && auto_refresh_expired && ref_expired?(ref)
+        log { "refreshing #{full_name}" }
+        clear_ref(ref)
+        ref = nil
+      end
+
+      value = nil
+
+      if ref
+        log { "hit #{full_name}" }
+        value = load_ref(ref.value)
+        unless value
+          clear_ref(full_name)
+          log { "missing #{full_name}" }
+        end
+      end
+
+      if value.nil?
+        # set the references to HOLDER so any recursive behavior ends up hitting a circular dependency error if the same fixture load is attempted
+        references[full_name] = HOLDER
+
+        value = dfn.call(store: self, execution_context: execution_context)
+
+        log { "store #{full_name}" }
+
+        ref = dump_ref(full_name, value)
+        ref = ::Fixtury::Reference.new(full_name, ref)
+        references[full_name] = ref
+      end
+
+      value
+    end
+    alias [] get
+
+    def load_ref(ref)
+      locator.load(ref)
+    end
+
+    def dump_ref(_name, value)
+      locator.dump(value)
+    end
+
+    def clear_ref(name)
+      references.delete(name)
+    end
+
+    def ref_expired?(ref)
+      return false unless ttl
+
+      ref.created_at < (Time.now.to_i - ttl)
+    end
+
+    def log(local_verbose = false, &block)
+      return unless verbose || local_verbose
+
+      puts "[fixtury|store] #{block.call}"
+    end
+
+  end
+end

data/lib/fixtury/tasks.rake

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+namespace :fixtury do
+  task :setup
+
+  desc "Clear fixtures from your cache. Accepts a pattern or fixture name such as foo/bar or /foo/*. Default pattern is /*"
+  task :clear_cache, [:pattern] => :setup do |_t, args|
+    ::Fixtury::Store.instance.clear_cache!(pattern: args[:pattern])
+  end
+end

data/lib/fixtury/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Fixtury
+
+  VERSION = "0.1.0.alpha"
+
+end

metadata

@@ -0,0 +1,202 @@
+--- !ruby/object:Gem::Specification
+name: fixtury
+version: !ruby/object:Gem::Version
+  version: 0.1.0.alpha
+platform: ruby
+authors:
+- Mike Nelson
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2020-01-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: autotest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: globalid
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: sqlite
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- mike@guideline.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".ruby-version"
+- ".travis.yml"
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- fixtury.gemspec
+- lib/fixtury.rb
+- lib/fixtury/definition.rb
+- lib/fixtury/errors/already_defined_error.rb
+- lib/fixtury/errors/circular_dependency_error.rb
+- lib/fixtury/errors/fixture_not_defined_error.rb
+- lib/fixtury/errors/schema_frozen_error.rb
+- lib/fixtury/errors/unrecognizable_locator_error.rb
+- lib/fixtury/execution_context.rb
+- lib/fixtury/hooks.rb
+- lib/fixtury/locator.rb
+- lib/fixtury/locator_backend/common.rb
+- lib/fixtury/locator_backend/globalid.rb
+- lib/fixtury/locator_backend/memory.rb
+- lib/fixtury/path.rb
+- lib/fixtury/railtie.rb
+- lib/fixtury/reference.rb
+- lib/fixtury/schema.rb
+- lib/fixtury/store.rb
+- lib/fixtury/tasks.rake
+- lib/fixtury/version.rb
+homepage: https://github.com/guideline-tech/fixtury
+licenses: []
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/guideline-tech/fixtury
+  source_code_uri: https://github.com/guideline-tech/fixtury
+  changelog_uri: https://github.com/guideline-tech/fixtury
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubygems_version: 3.0.6
+signing_key: 
+specification_version: 4
+summary: Treat fixtures like factories and factories like fixtures
+test_files: []