fixtury 0.2.1 → 0.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9090092db55914068c6478939047d638ee8bb678ee53a41f0d36380bf2df7dea
-  data.tar.gz: 4e58164635a72d63e059a5622b1c867556235ba09537e127b5498f94a3bf8e60
+  metadata.gz: 5419cf56fd821e06b8b0fc7d55f564d87e85aaab5e7e21933c5ef923f3f32294
+  data.tar.gz: e53da80eda66ee2abd07baec7ccd847ba18a5e8631b01014f7e62a43616ac509
 SHA512:
-  metadata.gz: 05e1ddd158beafe83cbe9e9d32abf10a49dcdb59709cc372f31a29a1a52c3eafe0b802eba8015ccdb429444678d94941db42dedb6202396b958c8d53d2e6f9d2
-  data.tar.gz: 70e2abc1abc6324e3523631a6f2caf936d0b0859eeb14b41fec843b766bf648d047b1e09e9d9bb6da60131f06be23e7e02c1adcf86be30910387581b7e191d3e
+  metadata.gz: a69c33f32f35346abae60a3f3c27f232dc813fbe551f99055d7e2fcc8eacd5c6873fdf5a925be4d3ef3635c7558577918018dc8c399674e26232fc0fd0a0d10e
+  data.tar.gz: 4b9e9f3f0c4e538248eda219cb57d6f618a870407ae8f9bfeabf17aab49850e8e253bfd77a7279a9b70b164b572fb41021211b22b46d6e656c7fc57e21af6959

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    fixtury (0.2.1)
+    fixtury (0.3.3)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -1,11 +1,14 @@
 # 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.
+Fixtury aims to provide an interface for creating, managing, and accessing test data in a simple and efficient way. It has no opinion on how you generate the data, it simply provides efficient ways to access it.
 
-For example, if a developer is running a test locally, there's no reason to build all fixtures for your suite.
+Often, fixture frameworks require you to either heavily maintain static fixtures or generate all your fixtures at runtime. Fixtury attempts to find a middle ground that enables a faster and more effecient development process.
 
-```
-class MyTest < ::Test
+For example, if a developer is running a test locally in their development environment there's no reason to build all fixtures for your suite of 30k tests. Instead, if we're able to track the fixture dependencies of the tests that are running we can build (and cache) the data relevant for the specific tests that are run.
+
+```ruby
+class MyTest < ::ActiveSupport::TestCase
+  include ::Fixtury::TestHooks
 
   fixtury "users.fresh"
   let(:user) { fixtury("users.fresh") }
@@ -15,7 +18,6 @@ class MyTest < ::Test
   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.

data/lib/fixtury.rb

@@ -10,11 +10,14 @@ require "fixtury/store"
 
 module Fixtury
 
+  # Shortcut for opening the top level schema.
   def self.define(&block)
     schema.define(&block)
     schema
   end
 
+  # The default top level schema. Fixtury::Schema instances can be completely self-contained but most
+  # usage would be through this shared definition.
   def self.schema
     @top_level_schema ||= ::Fixtury::Schema.new(parent: nil, name: "")
   end

data/lib/fixtury/definition.rb

@@ -1,18 +1,23 @@
 # frozen_string_literal: true
 
+require "fixtury/definition_executor"
+
 module Fixtury
   class Definition
 
     attr_reader :name
     attr_reader :schema
+    alias parent schema
+    attr_reader :options
 
     attr_reader :callable
     attr_reader :enhancements
 
-    def initialize(schema: nil, name:, &block)
+    def initialize(schema: nil, name:, options: {}, &block)
       @name = name
       @schema = schema
       @callable = block
+      @options = options
       @enhancements = []
     end
 
@@ -24,55 +29,23 @@ module Fixtury
       @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
+    def info
+      {
+        name: name,
+        loc: location_from_callable(callable),
+        enhancements: enhancements.map { |e| location_from_callable(e) },
+      }
     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: nil, value:)
-      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
-
-      provide_execution_context_hooks(execution_context) do |ctxt|
-        if args.length.positive?
-          ctxt.instance_exec(*args, &callable)
-        else
-          ctxt.instance_eval(&callable)
-        end
-      end
+    def call(store: nil, execution_context: nil)
+      executor = ::Fixtury::DefinitionExecutor.new(store: store, definition: self, execution_context: execution_context)
+      executor.__call
     end
 
-    def provide_execution_context_hooks(execution_context)
-      return yield self unless execution_context
+    def location_from_callable(callable)
+      return nil unless callable.respond_to?(:source_location)
 
-      execution_context.before_fixture(self) if execution_context.respond_to?(:before_fixture)
-      value = if execution_context.respond_to?(:around_fixture)
-        execution_context.around_fixture(self) { yield execution_context }
-      else
-        yield execution_context
-      end
-      execution_context.after_fixture(self, value) if execution_context.respond_to?(:after_fixture)
-      value
+      callable.source_location.join(":")
     end
 
   end

data/lib/fixtury/definition_executor.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Fixtury
+  class DefinitionExecutor
+
+    attr_reader :value, :execution_type, :definition, :store, :execution_context
+
+    def initialize(store: nil, execution_context: nil, definition:)
+      @store = store
+      @definition = definition
+      @execution_context = execution_context
+      @execution_type = nil
+      @value = nil
+    end
+
+    def __call
+      maybe_set_store_context do
+        provide_schema_hooks do
+          run_callable(callable: definition.callable, type: :definition)
+          definition.enhancements.each do |e|
+            run_callable(callable: e, type: :enhancement)
+          end
+        end
+      end
+
+      value
+    end
+
+    def get(name)
+      raise ArgumentError, "A store is required for #{definition.name}" unless store
+
+      store.get(name, execution_context: execution_context)
+    end
+    alias [] get
+
+    def method_missing(method_name, *args, &block)
+      return super unless execution_context
+
+      execution_context.send(method_name, *args, &block)
+    end
+
+    def respond_to_missing?(method_name)
+      return super unless execution_context
+
+      execution_context.respond_to?(method_name, true)
+    end
+
+    private
+
+    def run_callable(callable:, type:)
+      @execution_type = type
+
+      @value = if callable.arity.positive?
+        instance_exec(self, &callable)
+      else
+        instance_eval(&callable)
+      end
+    end
+
+    def maybe_set_store_context
+      return yield unless store
+
+      store.with_relative_schema(definition.schema) do
+        yield
+      end
+    end
+
+    def provide_schema_hooks
+      return yield unless definition.schema
+
+      @value = definition.schema.around_fixture_hook(self) do
+        yield
+        value
+      end
+    end
+
+  end
+end

data/lib/fixtury/reference.rb

@@ -9,12 +9,17 @@ module Fixtury
       new(name, HOLDER_VALUE)
     end
 
-    attr_reader :name, :value, :created_at
+    def self.create(name, value)
+      new(name, value)
+    end
+
+    attr_reader :name, :value, :created_at, :options
 
-    def initialize(name, value)
+    def initialize(name, value, options = {})
       @name = name
       @value = value
       @created_at = Time.now.to_i
+      @options = options
     end
 
     def holder?

data/lib/fixtury/schema.rb

@@ -9,16 +9,38 @@ require "fixtury/errors/schema_frozen_error"
 module Fixtury
   class Schema
 
-    attr_reader :definitions, :children, :name, :parent, :relative_name
+    attr_reader :definitions, :children, :name, :parent, :relative_name, :around_fixture_definition, :options
 
-    def initialize(parent:, name:)
+    def initialize(parent:, name:, options: {})
       @name = name
       @parent = parent
       @relative_name = @name.split("/").last
+      @around_fixture_definition = nil
+      @options = options
       @frozen = false
       reset!
     end
 
+    def around_fixture(&block)
+      @around_fixture_definition = block
+    end
+
+    def around_fixture_hook(executor, &definition)
+      maybe_invoke_parent_around_fixture_hook(executor) do
+        if around_fixture_definition.nil?
+          yield
+        else
+          around_fixture_definition.call(executor, definition)
+        end
+      end
+    end
+
+    def maybe_invoke_parent_around_fixture_hook(executor, &block)
+      return yield unless parent
+
+      parent.around_fixture_hook(executor, &block)
+    end
+
     def reset!
       @children = {}
       @definitions = {}
@@ -62,19 +84,19 @@ module Fixtury
       out.join("\n")
     end
 
-    def namespace(name, &block)
+    def namespace(name, options = {}, &block)
       ensure_not_frozen!
       ensure_no_conflict!(name: name, definitions: true, namespaces: false)
 
-      child = find_or_create_child_schema(name: name)
+      child = find_or_create_child_schema(name: name, options: options)
       child.instance_eval(&block) if block_given?
       child
     end
 
-    def fixture(name, &block)
+    def fixture(name, options = {}, &block)
       ensure_not_frozen!
       ensure_no_conflict!(name: name, definitions: true, namespaces: true)
-      create_child_definition(name: name, &block)
+      create_child_definition(name: name, options: options, &block)
     end
 
     def enhance(name, &block)
@@ -99,6 +121,8 @@ module Fixtury
         end
       end
 
+      around_fixture(&other_ns.around_fixture_definition) if other_ns.around_fixture_definition
+
       self
     end
 
@@ -163,31 +187,32 @@ module Fixtury
       children[name.to_s]
     end
 
-    def find_or_create_child_schema(name:)
+    def find_or_create_child_schema(name:, options:)
       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)
+          self.class.new(name: child_name, parent: self, options: options)
         end
       end
+      child
     end
 
     def find_child_definition(name:)
       definitions[name.to_s]
     end
 
-    def create_child_definition(name:, &block)
+    def create_child_definition(name:, options:, &block)
       child_name = build_child_name(name: name)
-      definition = ::Fixtury::Definition.new(name: child_name, schema: self, &block)
+      definition = ::Fixtury::Definition.new(name: child_name, schema: self, options: options, &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]+$/)
+      raise ArgumentError, "#{name} is invalid. `name` must contain only a-z, A-Z, 0-9, and _." unless /^[a-zA-Z_0-9]+$/.match?(name)
 
       arr = ["", self.name, name]
       arr.join("/").gsub(%r{/{2,}}, "/")

data/lib/fixtury/store.rb

@@ -21,7 +21,6 @@ module Fixtury
     attr_reader :filepath, :references, :ttl, :auto_refresh_expired
     attr_reader :schema, :locator
     attr_reader :log_level
-    attr_reader :execution_context
 
     def initialize(
       filepath: nil,
@@ -29,7 +28,6 @@ module Fixtury
       log_level: nil,
       ttl: nil,
       schema: nil,
-      execution_context: nil,
       auto_refresh_expired: false
     )
       @schema = schema || ::Fixtury.schema
@@ -39,7 +37,6 @@ module Fixtury
       @locator = locator
       @filepath = filepath
       @references = @filepath && ::File.file?(@filepath) ? ::YAML.load_file(@filepath) : {}
-      @execution_context = execution_context
       @ttl = ttl ? ttl.to_i : ttl
       @auto_refresh_expired = !!auto_refresh_expired
       self.class.instance ||= self
@@ -107,7 +104,7 @@ module Fixtury
       result
     end
 
-    def get(name)
+    def get(name, execution_context: nil)
       dfn = schema.get_definition!(name)
       full_name = dfn.name
       ref = references[full_name]

data/lib/fixtury/test_hooks.rb

@@ -11,6 +11,9 @@ module Fixtury
     included do
       class_attribute :fixtury_dependencies
       self.fixtury_dependencies = Set.new
+
+      class_attribute :local_fixtury_dependencies
+      self.local_fixtury_dependencies = Set.new
     end
 
     module ClassMethods
@@ -22,7 +25,7 @@ module Fixtury
         if block_given?
           raise ArgumentError, "A fixture cannot be defined in an anonymous class" if name.nil?
 
-          namespace = name.underscore
+          namespace = fixtury_namespace
 
           ns = ::Fixtury.schema
 
@@ -32,7 +35,7 @@ module Fixtury
 
           names.each do |fixture_name|
             ns.fixture(fixture_name, &definition)
-            self.fixtury_dependencies += ["#{namespace}/#{fixture_name}"]
+            self.local_fixtury_dependencies += ["/#{namespace}/#{fixture_name}"]
           end
 
         # otherwise, just record the dependency
@@ -40,14 +43,16 @@ module Fixtury
           self.fixtury_dependencies += names.flatten.compact.map(&:to_s)
         end
 
-        if opts[:accessor]
+        accessor_option = opts.key?(:accessor) ? opts[:accessor] : true
+
+        if accessor_option
 
-          if opts[:accessor] != true && names.length > 1
+          if accessor_option != true && names.length > 1
             raise ArgumentError, "A named :accessor option is only available when providing one fixture"
           end
 
           names.each do |fixture_name|
-            method_name = opts[:accessor] == true ? fixture_name.split("/").last : opts[:accessor]
+            method_name = accessor_option == true ? fixture_name.split("/").last : accessor_option
             ivar = :"@#{method_name}"
 
             class_eval <<-EV, __FILE__, __LINE__ + 1
@@ -62,6 +67,10 @@ module Fixtury
         end
       end
 
+      def fixtury_namespace
+        name.underscore
+      end
+
     end
 
     def fixtury(name)
@@ -69,18 +78,16 @@ module Fixtury
 
       name = name.to_s
 
-      unless name.include?("/")
-        local_name = "#{self.class.name.underscore}/#{name}"
-        if self.fixtury_dependencies.include?(local_name)
-          return fixtury_store.get(local_name)
-        end
+      local_alias = "/#{self.class.fixtury_namespace}/#{name}"
+      if self.local_fixtury_dependencies.include?(local_alias)
+        return fixtury_store.get(local_alias, execution_context: self)
       end
 
       unless self.fixtury_dependencies.include?(name)
         raise ArgumentError, "Unrecognized fixtury dependency `#{name}` for #{self.class}"
       end
 
-      fixtury_store.get(name)
+      fixtury_store.get(name, execution_context: self)
     end
 
     def fixtury_store
@@ -99,7 +106,7 @@ module Fixtury
 
     # piggybacking activerecord fixture setup for now.
     def setup_fixtures(*args)
-      if fixtury_dependencies.any?
+      if fixtury_dependencies.any? || local_fixtury_dependencies.any?
         setup_fixtury_fixtures
       else
         super
@@ -108,7 +115,7 @@ module Fixtury
 
     # piggybacking activerecord fixture setup for now.
     def teardown_fixtures(*args)
-      if fixtury_dependencies.any?
+      if fixtury_dependencies.any? || local_fixtury_dependencies.any?
         teardown_fixtury_fixtures
       else
         super
@@ -139,7 +146,7 @@ module Fixtury
     end
 
     def load_all_fixtury_fixtures!
-      fixtury_dependencies.each do |name|
+      (fixtury_dependencies | local_fixtury_dependencies).each do |name|
         fixtury(name) unless fixtury_loaded?(name)
       end
     end

data/lib/fixtury/version.rb

@@ -2,6 +2,6 @@
 
 module Fixtury
 
-  VERSION = "0.2.1"
+  VERSION = "0.3.3"
 
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fixtury
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.3
 platform: ruby
 authors:
 - Mike Nelson
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-10-13 00:00:00.000000000 Z
+date: 2020-10-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: autotest
@@ -155,6 +155,7 @@ files:
 - fixtury.gemspec
 - lib/fixtury.rb
 - lib/fixtury/definition.rb
+- lib/fixtury/definition_executor.rb
 - lib/fixtury/errors/already_defined_error.rb
 - lib/fixtury/errors/circular_dependency_error.rb
 - lib/fixtury/errors/fixture_not_defined_error.rb